Backed out changeset 17cfad44e12b (bug 1155963) for breaking b2g builds
authorWes Kocher <wkocher@mozilla.com>
Thu, 14 May 2015 16:35:18 -0700
changeset 264787 e43f6dc95fc5f3bbd31a71c147d606c1d0b215ec
parent 264786 4f320bb16ae4657356a2077bf2eed515806bbe50
child 264788 84a0206d0e69fb42203e78e1edcfb8b1fcd546d3
push id2076
push userwcosta@mozilla.com
push dateFri, 15 May 2015 17:17:28 +0000
bugs1155963
milestone41.0a1
backs out17cfad44e12bc7f4260fc31b39417350bc25f8c6
Backed out changeset 17cfad44e12b (bug 1155963) for breaking b2g builds
accessible/atk/Platform.cpp
caps/nsPrincipal.cpp
caps/nsSystemPrincipal.cpp
dom/fetch/Fetch.cpp
dom/indexedDB/ActorsParent.cpp
dom/quota/QuotaManager.cpp
extensions/cookie/nsPermissionManager.cpp
netwerk/base/Predictor.cpp
netwerk/cache2/CacheFileContextEvictor.cpp
netwerk/cache2/CacheFileIOManager.cpp
netwerk/cache2/CacheFileIOManager.h
netwerk/cache2/CacheIndex.cpp
netwerk/cookie/nsCookieService.cpp
netwerk/ipc/RemoteOpenFileChild.cpp
security/manager/ssl/src/CryptoTask.h
security/manager/ssl/src/nsCertOverrideService.cpp
startupcache/StartupCache.cpp
toolkit/components/places/nsPlacesMacros.h
toolkit/components/telemetry/Telemetry.cpp
toolkit/xre/nsUpdateDriver.cpp
xpcom/io/nsIFile.idl
xpcom/io/nsLocalFileUnix.cpp
xpcom/io/nsLocalFileWin.cpp
xpcom/string/nsLiteralString.h
xpfe/components/windowds/nsWindowDataSource.cpp
--- a/accessible/atk/Platform.cpp
+++ b/accessible/atk/Platform.cpp
@@ -356,17 +356,18 @@ dbus_done:
   if (reply)
     dbus_message_unref(reply);
 
   if (dbusSuccess)
     return sShouldEnable;
 #endif
 
   //check gconf-2 setting
-#define GCONF_A11Y_KEY "/desktop/gnome/interface/accessibility"
+static const char sGconfAccessibilityKey[] =
+    "/desktop/gnome/interface/accessibility";
   nsresult rv = NS_OK;
   nsCOMPtr<nsIGConfService> gconf =
     do_GetService(NS_GCONFSERVICE_CONTRACTID, &rv);
   if (NS_SUCCEEDED(rv) && gconf)
-    gconf->GetBool(NS_LITERAL_CSTRING(GCONF_A11Y_KEY), &sShouldEnable);
+    gconf->GetBool(NS_LITERAL_CSTRING(sGconfAccessibilityKey), &sShouldEnable);
 
   return sShouldEnable;
 }
--- a/caps/nsPrincipal.cpp
+++ b/caps/nsPrincipal.cpp
@@ -785,17 +785,17 @@ nsPrincipal::IsOnCSSUnprefixingWhitelist
       IsOnCSSUnprefixingWhitelistImpl(mCodebase));
   }
 
   return *mIsOnCSSUnprefixingWhitelist;
 }
 
 /************************************************************************************************************************/
 
-#define EXPANDED_PRINCIPAL_SPEC "[Expanded Principal]"
+static const char EXPANDED_PRINCIPAL_SPEC[] = "[Expanded Principal]";
 
 NS_IMPL_CLASSINFO(nsExpandedPrincipal, nullptr, nsIClassInfo::MAIN_THREAD_ONLY,
                   NS_EXPANDEDPRINCIPAL_CID)
 NS_IMPL_QUERY_INTERFACE_CI(nsExpandedPrincipal,
                            nsIPrincipal,
                            nsIExpandedPrincipal)
 NS_IMPL_CI_INTERFACE_GETTER(nsExpandedPrincipal,
                              nsIPrincipal,
@@ -1010,17 +1010,18 @@ nsExpandedPrincipal::IsOnCSSUnprefixingW
   // for an expanded principal. (And probably shouldn't be needed.)
   return false;
 }
 
 
 void
 nsExpandedPrincipal::GetScriptLocation(nsACString& aStr)
 {
-  aStr.AssignLiteral(EXPANDED_PRINCIPAL_SPEC " (");
+  aStr.Assign(EXPANDED_PRINCIPAL_SPEC);
+  aStr.AppendLiteral(" (");
 
   for (size_t i = 0; i < mPrincipals.Length(); ++i) {
     if (i != 0) {
       aStr.AppendLiteral(", ");
     }
 
     nsAutoCString spec;
     nsJSPrincipals::get(mPrincipals.ElementAt(i))->GetScriptLocation(spec);
--- a/caps/nsSystemPrincipal.cpp
+++ b/caps/nsSystemPrincipal.cpp
@@ -46,22 +46,22 @@ nsSystemPrincipal::Release()
   NS_LOG_RELEASE(this, count, "nsSystemPrincipal");
   if (count == 0) {
     delete this;
   }
 
   return count;
 }
 
-#define SYSTEM_PRINCIPAL_SPEC "[System Principal]"
+static const char SYSTEM_PRINCIPAL_SPEC[] = "[System Principal]";
 
 void
 nsSystemPrincipal::GetScriptLocation(nsACString &aStr)
 {
-    aStr.AssignLiteral(SYSTEM_PRINCIPAL_SPEC);
+    aStr.Assign(SYSTEM_PRINCIPAL_SPEC);
 }
 
 #ifdef DEBUG
 void nsSystemPrincipal::dumpImpl()
 {
   fprintf(stderr, "nsSystemPrincipal (%p)\n", this);
 }
 #endif 
--- a/dom/fetch/Fetch.cpp
+++ b/dom/fetch/Fetch.cpp
@@ -1522,17 +1522,17 @@ FetchBody<Derived>::ContinueConsumeBody(
       autoFree.Reset();
       return;
     }
     case CONSUME_FORMDATA: {
       nsCString data;
       data.Adopt(reinterpret_cast<char*>(aResult), aResultLength);
       autoFree.Reset();
 
-      NS_NAMED_LITERAL_CSTRING(formDataMimeType, "multipart/form-data");
+      NS_NAMED_LITERAL_CSTRING(formDataMimeType, NS_LITERAL_CSTRING("multipart/form-data"));
 
       // Allow semicolon separated boundary/encoding suffix like multipart/form-data; boundary=
       // but disallow multipart/form-datafoobar.
       bool isValidFormDataMimeType = StringBeginsWith(mMimeType, formDataMimeType);
 
       if (isValidFormDataMimeType && mMimeType.Length() > formDataMimeType.Length()) {
         isValidFormDataMimeType = mMimeType[formDataMimeType.Length()] == ';';
       }
@@ -1545,17 +1545,17 @@ FetchBody<Derived>::ContinueConsumeBody(
           localPromise->MaybeReject(result);
           return;
         }
 
         nsRefPtr<nsFormData> fd = parser.FormData();
         MOZ_ASSERT(fd);
         localPromise->MaybeResolve(fd);
       } else {
-        NS_NAMED_LITERAL_CSTRING(urlDataMimeType, "application/x-www-form-urlencoded");
+        NS_NAMED_LITERAL_CSTRING(urlDataMimeType, NS_LITERAL_CSTRING("application/x-www-form-urlencoded"));
         bool isValidUrlEncodedMimeType = StringBeginsWith(mMimeType, urlDataMimeType);
 
         if (isValidUrlEncodedMimeType && mMimeType.Length() > urlDataMimeType.Length()) {
           isValidUrlEncodedMimeType = mMimeType[urlDataMimeType.Length()] == ';';
         }
 
         if (isValidUrlEncodedMimeType) {
           nsRefPtr<URLSearchParams> params = new URLSearchParams();
--- a/dom/indexedDB/ActorsParent.cpp
+++ b/dom/indexedDB/ActorsParent.cpp
@@ -211,34 +211,40 @@ const uint32_t kConnectionIdleCheckpoint
 
 // The length of time that database connections will be held open after all
 // transactions and checkpointing  have completed.
 const uint32_t kConnectionIdleCloseMS = 10 * 1000; // 10 seconds
 
 // The length of time that idle threads will stay alive before being shut down.
 const uint32_t kConnectionThreadIdleMS = 30 * 1000; // 30 seconds
 
-#define SAVEPOINT_CLAUSE "SAVEPOINT sp;"
+const char kSavepointClause[] = "SAVEPOINT sp;";
 
 const uint32_t kFileCopyBufferSize = 32768;
 
-#define JOURNAL_DIRECTORY_NAME "journals"
+const char kJournalDirectoryName[] = "journals";
 
 const char kFileManagerDirectoryNameSuffix[] = ".files";
 const char kSQLiteJournalSuffix[] = ".sqlite-journal";
 const char kSQLiteSHMSuffix[] = ".sqlite-shm";
 const char kSQLiteWALSuffix[] = ".sqlite-wal";
 
 const char kPrefIndexedDBEnabled[] = "dom.indexedDB.enabled";
 
 #define IDB_PREFIX "indexedDB"
 
-#define PERMISSION_STRING_CHROME_BASE IDB_PREFIX "-chrome-"
-#define PERMISSION_STRING_CHROME_READ_SUFFIX "-read"
-#define PERMISSION_STRING_CHROME_WRITE_SUFFIX "-write"
+#ifdef MOZ_CHILD_PERMISSIONS
+const char kPermissionString[] = IDB_PREFIX;
+#endif // MOZ_CHILD_PERMISSIONS
+
+const char kPermissionStringChromeBase[] = IDB_PREFIX "-chrome-";
+const char kPermissionStringChromeReadSuffix[] = "-read";
+const char kPermissionStringChromeWriteSuffix[] = "-write";
+
+#undef IDB_PREFIX
 
 enum AppId {
   kNoAppId = nsIScriptSecurityManager::NO_APP_ID,
   kUnknownAppId = nsIScriptSecurityManager::UNKNOWN_APP_ID
 };
 
 #ifdef DEBUG
 
@@ -4369,16 +4375,28 @@ public:
 
     return mUpdateRefcountFunction;
   }
 
   nsresult
   GetCachedStatement(const nsACString& aQuery,
                      CachedStatement* aCachedStatement);
 
+  template <size_t N>
+  nsresult
+  GetCachedStatement(const char (&aQuery)[N],
+                     CachedStatement* aCachedStatement)
+  {
+    static_assert(N > 1, "Must have a non-empty string!");
+    AssertIsOnConnectionThread();
+    MOZ_ASSERT(aCachedStatement);
+
+    return GetCachedStatement(NS_LITERAL_CSTRING(aQuery), aCachedStatement);
+  }
+
   nsresult
   BeginWriteTransaction();
 
   void
   RollbackWriteTransaction();
 
   void
   FinishWriteTransaction();
@@ -8324,17 +8342,17 @@ DatabaseConnection::~DatabaseConnection(
 
 nsresult
 DatabaseConnection::Init()
 {
   AssertIsOnConnectionThread();
   MOZ_ASSERT(!mInWriteTransaction);
 
   CachedStatement stmt;
-  nsresult rv = GetCachedStatement(NS_LITERAL_CSTRING("BEGIN"), &stmt);
+  nsresult rv = GetCachedStatement("BEGIN", &stmt);
   if (NS_WARN_IF(NS_FAILED(rv))) {
     return rv;
   }
 
   rv = stmt->Execute();
   if (NS_WARN_IF(NS_FAILED(rv))) {
     return rv;
   }
@@ -8391,17 +8409,17 @@ DatabaseConnection::BeginWriteTransactio
   MOZ_ASSERT(!mInWriteTransaction);
 
   PROFILER_LABEL("IndexedDB",
                  "DatabaseConnection::BeginWriteTransaction",
                  js::ProfileEntry::Category::STORAGE);
 
   // Release our read locks.
   CachedStatement rollbackStmt;
-  nsresult rv = GetCachedStatement(NS_LITERAL_CSTRING("ROLLBACK"), &rollbackStmt);
+  nsresult rv = GetCachedStatement("ROLLBACK", &rollbackStmt);
   if (NS_WARN_IF(NS_FAILED(rv))) {
     return rv;
   }
 
   rv = rollbackStmt->Execute();
   if (NS_WARN_IF(NS_FAILED(rv))) {
     return rv;
   }
@@ -8419,17 +8437,17 @@ DatabaseConnection::BeginWriteTransactio
     if (NS_WARN_IF(NS_FAILED(rv))) {
       return rv;
     }
 
     mUpdateRefcountFunction.swap(function);
   }
 
   CachedStatement beginStmt;
-  rv = GetCachedStatement(NS_LITERAL_CSTRING("BEGIN IMMEDIATE"), &beginStmt);
+  rv = GetCachedStatement("BEGIN IMMEDIATE", &beginStmt);
   if (NS_WARN_IF(NS_FAILED(rv))) {
     return rv;
   }
 
   rv = beginStmt->Execute();
   if (rv == NS_ERROR_STORAGE_BUSY) {
     NS_WARNING("Received NS_ERROR_STORAGE_BUSY when attempting to start write "
                "transaction, retrying for up to 10 seconds");
@@ -8468,17 +8486,17 @@ DatabaseConnection::RollbackWriteTransac
                  "DatabaseConnection::RollbackWriteTransaction",
                  js::ProfileEntry::Category::STORAGE);
 
   if (!mInWriteTransaction) {
     return;
   }
 
   DatabaseConnection::CachedStatement stmt;
-  nsresult rv = GetCachedStatement(NS_LITERAL_CSTRING("ROLLBACK"), &stmt);
+  nsresult rv = GetCachedStatement("ROLLBACK", &stmt);
   if (NS_WARN_IF(NS_FAILED(rv))) {
     return;
   }
 
   // This may fail if SQLite already rolled back the transaction so ignore any
   // errors.
   unused << stmt->Execute();
 }
@@ -8499,17 +8517,17 @@ DatabaseConnection::FinishWriteTransacti
 
   if (!mInWriteTransaction) {
     return;
   }
 
   mInWriteTransaction = false;
 
   CachedStatement stmt;
-  nsresult rv = GetCachedStatement(NS_LITERAL_CSTRING("BEGIN"), &stmt);
+  nsresult rv = GetCachedStatement("BEGIN", &stmt);
   if (NS_WARN_IF(NS_FAILED(rv))) {
     return;
   }
 
   rv = stmt->Execute();
   if (NS_WARN_IF(NS_FAILED(rv))) {
     return;
   }
@@ -8523,17 +8541,17 @@ DatabaseConnection::StartSavepoint()
   MOZ_ASSERT(mUpdateRefcountFunction);
   MOZ_ASSERT(mInWriteTransaction);
 
   PROFILER_LABEL("IndexedDB",
                  "DatabaseConnection::StartSavepoint",
                  js::ProfileEntry::Category::STORAGE);
 
   CachedStatement stmt;
-  nsresult rv = GetCachedStatement(NS_LITERAL_CSTRING(SAVEPOINT_CLAUSE), &stmt);
+  nsresult rv = GetCachedStatement(kSavepointClause, &stmt);
   if (NS_WARN_IF(NS_FAILED(rv))) {
     return rv;
   }
 
   rv = stmt->Execute();
   if (NS_WARN_IF(NS_FAILED(rv))) {
     return rv;
   }
@@ -8557,17 +8575,17 @@ DatabaseConnection::ReleaseSavepoint()
   MOZ_ASSERT(mInWriteTransaction);
 
   PROFILER_LABEL("IndexedDB",
                  "DatabaseConnection::ReleaseSavepoint",
                  js::ProfileEntry::Category::STORAGE);
 
   CachedStatement stmt;
   nsresult rv = GetCachedStatement(
-    NS_LITERAL_CSTRING("RELEASE " SAVEPOINT_CLAUSE),
+    NS_LITERAL_CSTRING("RELEASE ") + NS_LITERAL_CSTRING(kSavepointClause),
     &stmt);
   if (NS_SUCCEEDED(rv)) {
     rv = stmt->Execute();
     if (NS_SUCCEEDED(rv)) {
       mUpdateRefcountFunction->ReleaseSavepoint();
 
 #ifdef DEBUG
       MOZ_ASSERT(mDEBUGSavepointCount);
@@ -8595,17 +8613,17 @@ DatabaseConnection::RollbackSavepoint()
   MOZ_ASSERT(mDEBUGSavepointCount);
   mDEBUGSavepointCount--;
 #endif
 
   mUpdateRefcountFunction->RollbackSavepoint();
 
   CachedStatement stmt;
   nsresult rv = GetCachedStatement(
-    NS_LITERAL_CSTRING("ROLLBACK TO " SAVEPOINT_CLAUSE),
+    NS_LITERAL_CSTRING("ROLLBACK TO ") + NS_LITERAL_CSTRING(kSavepointClause),
     &stmt);
   if (NS_WARN_IF(NS_FAILED(rv))) {
     return rv;
   }
 
   // This may fail if SQLite already rolled back the savepoint so ignore any
   // errors.
   unused << stmt->Execute();
@@ -8617,24 +8635,32 @@ nsresult
 DatabaseConnection::Checkpoint(bool aIdle)
 {
   AssertIsOnConnectionThread();
 
   PROFILER_LABEL("IndexedDB",
                  "DatabaseConnection::Checkpoint",
                  js::ProfileEntry::Category::STORAGE);
 
+  nsAutoCString checkpointMode;
+  if (aIdle) {
+    // When idle we want to reclaim disk space.
+    checkpointMode.AssignLiteral("TRUNCATE");
+  } else {
+    // We're being called at the end of a READ_WRITE_FLUSH transaction so make
+    // sure that the database is completely checkpointed and flushed to disk.
+    checkpointMode.AssignLiteral("FULL");
+  }
+
   CachedStatement stmt;
   nsresult rv =
-    GetCachedStatement(aIdle ?
-    // When idle we want to reclaim disk space.
-      NS_LITERAL_CSTRING("PRAGMA wal_checkpoint(TRUNCATE)") :
-    // We're being called at the end of a READ_WRITE_FLUSH transaction so make
-    // sure that the database is completely checkpointed and flushed to disk.
-      NS_LITERAL_CSTRING("PRAGMA wal_checkpoint(FULL)"),
+    GetCachedStatement(
+      NS_LITERAL_CSTRING("PRAGMA wal_checkpoint(") +
+      checkpointMode +
+      NS_LITERAL_CSTRING(")"),
       &stmt);
   if (NS_WARN_IF(NS_FAILED(rv))) {
     return rv;
   }
 
   rv = stmt->Execute();
   if (NS_WARN_IF(NS_FAILED(rv))) {
     return rv;
@@ -9214,20 +9240,20 @@ DatabaseUpdateFunction::UpdateInternal(i
   DatabaseConnection* connection = mFunction->mConnection;
   MOZ_ASSERT(connection);
   connection->AssertIsOnConnectionThread();
 
   MOZ_ASSERT(connection->GetStorageConnection());
 
   nsresult rv;
   if (!mUpdateStatement) {
-    rv = connection->GetCachedStatement(NS_LITERAL_CSTRING(
+    rv = connection->GetCachedStatement(
       "UPDATE file "
       "SET refcount = refcount + :delta "
-      "WHERE id = :id"),
+      "WHERE id = :id",
       &mUpdateStatement);
     if (NS_WARN_IF(NS_FAILED(rv))) {
       return rv;
     }
   }
 
   mozStorageStatementScoper updateScoper(mUpdateStatement);
 
@@ -9249,20 +9275,20 @@ DatabaseUpdateFunction::UpdateInternal(i
   int32_t rows;
   rv = connection->GetStorageConnection()->GetAffectedRows(&rows);
   if (NS_WARN_IF(NS_FAILED(rv))) {
     return rv;
   }
 
   if (rows > 0) {
     if (!mSelectStatement) {
-      rv = connection->GetCachedStatement(NS_LITERAL_CSTRING(
+      rv = connection->GetCachedStatement(
         "SELECT id "
         "FROM file "
-        "WHERE id = :id"),
+        "WHERE id = :id",
         &mSelectStatement);
       if (NS_WARN_IF(NS_FAILED(rv))) {
         return rv;
       }
     }
 
     mozStorageStatementScoper selectScoper(mSelectStatement);
 
@@ -9282,19 +9308,19 @@ DatabaseUpdateFunction::UpdateInternal(i
       // just before commit
       mFunction->mJournalsToCreateBeforeCommit.AppendElement(aId);
     }
 
     return NS_OK;
   }
 
   if (!mInsertStatement) {
-    rv = connection->GetCachedStatement(NS_LITERAL_CSTRING(
+    rv = connection->GetCachedStatement(
       "INSERT INTO file (id, refcount) "
-      "VALUES(:id, :delta)"),
+      "VALUES(:id, :delta)",
       &mInsertStatement);
     if (NS_WARN_IF(NS_FAILED(rv))) {
       return rv;
     }
   }
 
   mozStorageStatementScoper insertScoper(mInsertStatement);
 
@@ -14239,17 +14265,18 @@ FileManager::Init(nsIFile* aDirectory,
   }
 
   nsCOMPtr<nsIFile> journalDirectory;
   rv = aDirectory->Clone(getter_AddRefs(journalDirectory));
   if (NS_WARN_IF(NS_FAILED(rv))) {
     return rv;
   }
 
-  rv = journalDirectory->Append(NS_LITERAL_STRING(JOURNAL_DIRECTORY_NAME));
+  NS_ConvertASCIItoUTF16 dirName(NS_LITERAL_CSTRING(kJournalDirectoryName));
+  rv = journalDirectory->Append(dirName);
   if (NS_WARN_IF(NS_FAILED(rv))) {
     return rv;
   }
 
   rv = journalDirectory->Exists(&exists);
   if (NS_WARN_IF(NS_FAILED(rv))) {
     return rv;
   }
@@ -14491,17 +14518,18 @@ FileManager::InitDirectory(nsIFile* aDir
   }
 
   nsCOMPtr<nsIFile> journalDirectory;
   rv = aDirectory->Clone(getter_AddRefs(journalDirectory));
   if (NS_WARN_IF(NS_FAILED(rv))) {
     return rv;
   }
 
-  rv = journalDirectory->Append(NS_LITERAL_STRING(JOURNAL_DIRECTORY_NAME));
+  NS_ConvertASCIItoUTF16 dirName(NS_LITERAL_CSTRING(kJournalDirectoryName));
+  rv = journalDirectory->Append(dirName);
   if (NS_WARN_IF(NS_FAILED(rv))) {
     return rv;
   }
 
   rv = journalDirectory->Exists(&exists);
   if (NS_WARN_IF(NS_FAILED(rv))) {
     return rv;
   }
@@ -14674,17 +14702,17 @@ FileManager::GetUsage(nsIFile* aDirector
     MOZ_ASSERT(file);
 
     nsString leafName;
     rv = file->GetLeafName(leafName);
     if (NS_WARN_IF(NS_FAILED(rv))) {
       return rv;
     }
 
-    if (leafName.EqualsLiteral(JOURNAL_DIRECTORY_NAME)) {
+    if (leafName.EqualsLiteral(kJournalDirectoryName)) {
       continue;
     }
 
     int64_t fileSize;
     rv = file->GetFileSize(&fileSize);
     if (NS_WARN_IF(NS_FAILED(rv))) {
       return rv;
     }
@@ -15243,17 +15271,17 @@ QuotaClient::GetUsageForDirectoryInterna
         }
       } else {
         nsString leafName;
         rv = file->GetLeafName(leafName);
         if (NS_WARN_IF(NS_FAILED(rv))) {
           return rv;
         }
 
-        if (!leafName.EqualsLiteral(JOURNAL_DIRECTORY_NAME)) {
+        if (!leafName.EqualsLiteral(kJournalDirectoryName)) {
           NS_WARNING("Unknown directory found!");
         }
       }
 
       continue;
     }
 
     int64_t fileSize;
@@ -16011,29 +16039,29 @@ DatabaseOperationBase::InsertIndexTableR
     const IndexDataValue& info = aIndexValues[index];
 
     DatabaseConnection::CachedStatement& stmt =
       info.mUnique ? insertUniqueStmt : insertStmt;
 
     if (stmt) {
       stmt.Reset();
     } else if (info.mUnique) {
-      rv = aConnection->GetCachedStatement(NS_LITERAL_CSTRING(
+      rv = aConnection->GetCachedStatement(
         "INSERT INTO unique_index_data "
           "(index_id, value, object_store_id, object_data_key) "
-          "VALUES (:index_id, :value, :object_store_id, :object_data_key);"),
+          "VALUES (:index_id, :value, :object_store_id, :object_data_key);",
         &stmt);
       if (NS_WARN_IF(NS_FAILED(rv))) {
         return rv;
       }
     } else {
-      rv = aConnection->GetCachedStatement(NS_LITERAL_CSTRING(
+      rv = aConnection->GetCachedStatement(
         "INSERT OR IGNORE INTO index_data "
           "(index_id, value, object_data_key, object_store_id) "
-          "VALUES (:index_id, :value, :object_data_key, :object_store_id);"),
+          "VALUES (:index_id, :value, :object_data_key, :object_store_id);",
         &stmt);
       if (NS_WARN_IF(NS_FAILED(rv))) {
         return rv;
       }
     }
 
     rv = stmt->BindInt64ByName(indexIdString, info.mIndexId);
     if (NS_WARN_IF(NS_FAILED(rv))) {
@@ -16113,30 +16141,30 @@ DatabaseOperationBase::DeleteIndexDataTa
     const IndexDataValue& indexValue = aIndexValues[index];
 
     DatabaseConnection::CachedStatement& stmt =
       indexValue.mUnique ? deleteUniqueStmt : deleteStmt;
 
     if (stmt) {
       stmt.Reset();
     } else if (indexValue.mUnique) {
-      rv = aConnection->GetCachedStatement(NS_LITERAL_CSTRING(
+      rv = aConnection->GetCachedStatement(
         "DELETE FROM unique_index_data "
           "WHERE index_id = :index_id "
-          "AND value = :value;"),
+          "AND value = :value;",
         &stmt);
       if (NS_WARN_IF(NS_FAILED(rv))) {
         return rv;
       }
     } else {
-      rv = aConnection->GetCachedStatement(NS_LITERAL_CSTRING(
+      rv = aConnection->GetCachedStatement(
         "DELETE FROM index_data "
           "WHERE index_id = :index_id "
           "AND value = :value "
-          "AND object_data_key = :object_data_key;"),
+          "AND object_data_key = :object_data_key;",
         &stmt);
       if (NS_WARN_IF(NS_FAILED(rv))) {
         return rv;
       }
     }
 
     rv = stmt->BindInt64ByName(indexIdString, indexValue.mIndexId);
     if (NS_WARN_IF(NS_FAILED(rv))) {
@@ -16189,21 +16217,21 @@ DatabaseOperationBase::DeleteObjectStore
   NS_NAMED_LITERAL_CSTRING(objectStoreIdString, "object_store_id");
   NS_NAMED_LITERAL_CSTRING(keyString, "key");
 
   nsresult rv;
   Key objectStoreKey;
   DatabaseConnection::CachedStatement selectStmt;
 
   if (singleRowOnly) {
-    rv = aConnection->GetCachedStatement(NS_LITERAL_CSTRING(
+    rv = aConnection->GetCachedStatement(
       "SELECT index_data_values "
         "FROM object_data "
         "WHERE object_store_id = :object_store_id "
-        "AND key = :key;"),
+        "AND key = :key;",
       &selectStmt);
     if (NS_WARN_IF(NS_FAILED(rv))) {
       return rv;
     }
 
     objectStoreKey = aKeyRange.get_SerializedKeyRange().lower();
 
     rv = objectStoreKey.BindToStatement(selectStmt, keyString);
@@ -16266,20 +16294,20 @@ DatabaseOperationBase::DeleteObjectStore
     rv = DeleteIndexDataTableRows(aConnection, objectStoreKey, indexValues);
     if (NS_WARN_IF(NS_FAILED(rv))) {
       return rv;
     }
 
     if (deleteStmt) {
       MOZ_ALWAYS_TRUE(NS_SUCCEEDED(deleteStmt->Reset()));
     } else {
-      rv = aConnection->GetCachedStatement(NS_LITERAL_CSTRING(
+      rv = aConnection->GetCachedStatement(
         "DELETE FROM object_data "
           "WHERE object_store_id = :object_store_id "
-          "AND key = :key;"),
+          "AND key = :key;",
         &deleteStmt);
       if (NS_WARN_IF(NS_FAILED(rv))) {
         return rv;
       }
     }
 
     rv = deleteStmt->BindInt64ByName(objectStoreIdString, aObjectStoreId);
     if (NS_WARN_IF(NS_FAILED(rv))) {
@@ -16330,21 +16358,21 @@ DatabaseOperationBase::UpdateIndexValues
                                               &indexDataValuesLength);
   if (NS_WARN_IF(NS_FAILED(rv))) {
     return rv;
   }
 
   MOZ_ASSERT(!indexDataValuesLength == !(indexDataValues.get()));
 
   DatabaseConnection::CachedStatement updateStmt;
-  rv = aConnection->GetCachedStatement(NS_LITERAL_CSTRING(
+  rv = aConnection->GetCachedStatement(
     "UPDATE object_data "
       "SET index_data_values = :index_data_values "
       "WHERE object_store_id = :object_store_id "
-      "AND key = :key;"),
+      "AND key = :key;",
     &updateStmt);
   if (NS_WARN_IF(NS_FAILED(rv))) {
     return rv;
   }
 
   NS_NAMED_LITERAL_CSTRING(indexDataValuesString, "index_data_values");
 
   if (indexDataValues) {
@@ -16391,20 +16419,20 @@ DatabaseOperationBase::ObjectStoreHasInd
 {
   MOZ_ASSERT(aConnection);
   aConnection->AssertIsOnConnectionThread();
   MOZ_ASSERT(aObjectStoreId);
 
   DatabaseConnection::CachedStatement stmt;
 
   MOZ_ALWAYS_TRUE(NS_SUCCEEDED(
-    aConnection->GetCachedStatement(NS_LITERAL_CSTRING(
+    aConnection->GetCachedStatement(
       "SELECT id "
         "FROM object_store_index "
-        "WHERE object_store_id = :object_store_id;"),
+        "WHERE object_store_id = :object_store_id;",
       &stmt)));
 
   MOZ_ALWAYS_TRUE(NS_SUCCEEDED(
     stmt->BindInt64ByName(NS_LITERAL_CSTRING("object_store_id"),
                           aObjectStoreId)));
 
   bool hasResult;
   MOZ_ALWAYS_TRUE(NS_SUCCEEDED(stmt->ExecuteStep(&hasResult)));
@@ -16753,20 +16781,20 @@ FactoryOp::CheckPermission(ContentParent
   if (principalInfo.type() == PrincipalInfo::TSystemPrincipalInfo) {
     MOZ_ASSERT(mState == State_Initial);
     MOZ_ASSERT(persistenceType == PERSISTENCE_TYPE_PERSISTENT);
 
     if (aContentParent) {
       // Check to make sure that the child process has access to the database it
       // is accessing.
       NS_NAMED_LITERAL_CSTRING(permissionStringBase,
-                               PERMISSION_STRING_CHROME_BASE);
+                               kPermissionStringChromeBase);
       NS_ConvertUTF16toUTF8 databaseName(mCommonParams.metadata().name());
-      NS_NAMED_LITERAL_CSTRING(readSuffix, PERMISSION_STRING_CHROME_READ_SUFFIX);
-      NS_NAMED_LITERAL_CSTRING(writeSuffix, PERMISSION_STRING_CHROME_WRITE_SUFFIX);
+      NS_NAMED_LITERAL_CSTRING(readSuffix, kPermissionStringChromeReadSuffix);
+      NS_NAMED_LITERAL_CSTRING(writeSuffix, kPermissionStringChromeWriteSuffix);
 
       const nsAutoCString permissionStringWrite =
         permissionStringBase + databaseName + writeSuffix;
       const nsAutoCString permissionStringRead =
         permissionStringBase + databaseName + readSuffix;
 
       bool canWrite =
         CheckAtLeastOneAppHasPermission(aContentParent, permissionStringWrite);
@@ -16845,17 +16873,17 @@ FactoryOp::CheckPermission(ContentParent
 #ifdef MOZ_CHILD_PERMISSIONS
     if (aContentParent) {
       if (NS_WARN_IF(!AssertAppPrincipal(aContentParent, principal))) {
         IDB_REPORT_INTERNAL_ERR();
         return NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR;
       }
 
       uint32_t intPermission =
-        mozilla::CheckPermission(aContentParent, principal, IDB_PREFIX);
+        mozilla::CheckPermission(aContentParent, principal, kPermissionString);
 
       permission =
         PermissionRequestBase::PermissionValueForIntPermission(intPermission);
     } else
 #endif // MOZ_CHILD_PERMISSIONS
     {
       rv = PermissionRequestBase::GetCurrentPermission(principal, &permission);
       if (NS_WARN_IF(NS_FAILED(rv))) {
@@ -18338,27 +18366,28 @@ VersionChangeOp::DoDatabaseWork(Database
                IDB_LOG_ID_STRING(mBackgroundChildLoggingId),
                mLoggingSerialNumber);
 
   nsresult rv = aConnection->BeginWriteTransaction();
   if (NS_WARN_IF(NS_FAILED(rv))) {
     return rv;
   }
 
+  NS_NAMED_LITERAL_CSTRING(version, "version");
+
   DatabaseConnection::CachedStatement updateStmt;
   rv = aConnection->GetCachedStatement(
     NS_LITERAL_CSTRING("UPDATE database "
-                       "SET version = :version"),
+                       "SET version = :") + version,
     &updateStmt);
   if (NS_WARN_IF(NS_FAILED(rv))) {
     return rv;
   }
 
-  rv = updateStmt->BindInt64ByName(NS_LITERAL_CSTRING("version"),
-                                   int64_t(mRequestedVersion));
+  rv = updateStmt->BindInt64ByName(version, int64_t(mRequestedVersion));
   if (NS_WARN_IF(NS_FAILED(rv))) {
     return rv;
   }
 
   rv = updateStmt->Execute();
   if (NS_WARN_IF(NS_FAILED(rv))) {
     return rv;
   }
@@ -19390,31 +19419,31 @@ CommitOp::AssertForeignKeyConsistency(Da
 {
   MOZ_ASSERT(aConnection);
   MOZ_ASSERT(mTransaction);
   mTransaction->AssertIsOnConnectionThread();
   MOZ_ASSERT(mTransaction->GetMode() != IDBTransaction::READ_ONLY);
 
   DatabaseConnection::CachedStatement pragmaStmt;
   MOZ_ALWAYS_TRUE(NS_SUCCEEDED(
-    aConnection->GetCachedStatement(NS_LITERAL_CSTRING("PRAGMA foreign_keys;"), &pragmaStmt)));
+    aConnection->GetCachedStatement("PRAGMA foreign_keys;", &pragmaStmt)));
 
   bool hasResult;
   MOZ_ALWAYS_TRUE(NS_SUCCEEDED(pragmaStmt->ExecuteStep(&hasResult)));
 
   MOZ_ASSERT(hasResult);
 
   int32_t foreignKeysEnabled;
   MOZ_ALWAYS_TRUE(NS_SUCCEEDED(pragmaStmt->GetInt32(0, &foreignKeysEnabled)));
 
   MOZ_ASSERT(foreignKeysEnabled, "Database doesn't have foreign keys enabled!");
 
   DatabaseConnection::CachedStatement checkStmt;
   MOZ_ALWAYS_TRUE(NS_SUCCEEDED(
-    aConnection->GetCachedStatement(NS_LITERAL_CSTRING("PRAGMA foreign_key_check;"), &checkStmt)));
+    aConnection->GetCachedStatement("PRAGMA foreign_key_check;", &checkStmt)));
 
   MOZ_ALWAYS_TRUE(NS_SUCCEEDED(checkStmt->ExecuteStep(&hasResult)));
 
   MOZ_ASSERT(!hasResult, "Database has inconsisistent foreign keys!");
 }
 
 #endif // DEBUG
 
@@ -19457,17 +19486,17 @@ CommitOp::Run()
           mResultCode = WriteAutoIncrementCounts();
           NS_WARN_IF_FALSE(NS_SUCCEEDED(mResultCode),
                            "WriteAutoIncrementCounts() failed!");
 
           if (NS_SUCCEEDED(mResultCode)) {
             AssertForeignKeyConsistency(connection);
 
             DatabaseConnection::CachedStatement stmt;
-            mResultCode = connection->GetCachedStatement(NS_LITERAL_CSTRING("COMMIT"), &stmt);
+            mResultCode = connection->GetCachedStatement("COMMIT", &stmt);
             NS_WARN_IF_FALSE(NS_SUCCEEDED(mResultCode),
                              "Failed to get 'COMMIT' statement!");
 
             if (NS_SUCCEEDED(mResultCode)) {
               mResultCode = stmt->Execute();
               NS_WARN_IF_FALSE(NS_SUCCEEDED(mResultCode), "Commit failed!");
 
               if (mTransaction->GetMode() == IDBTransaction::READ_WRITE_FLUSH &&
@@ -19608,20 +19637,20 @@ CreateObjectStoreOp::DoDatabaseWork(Data
 
 #ifdef DEBUG
   {
     // Make sure that we're not creating an object store with the same name as
     // another that already exists. This should be impossible because we should
     // have thrown an error long before now...
     DatabaseConnection::CachedStatement stmt;
     MOZ_ALWAYS_TRUE(NS_SUCCEEDED(
-      aConnection->GetCachedStatement(NS_LITERAL_CSTRING(
+      aConnection->GetCachedStatement(
         "SELECT name "
           "FROM object_store "
-          "WHERE name = :name;"),
+          "WHERE name = :name;",
         &stmt)));
 
     MOZ_ALWAYS_TRUE(NS_SUCCEEDED(
       stmt->BindStringByName(NS_LITERAL_CSTRING("name"), mMetadata.name())));
 
     bool hasResult;
     MOZ_ALWAYS_TRUE(NS_SUCCEEDED(stmt->ExecuteStep(&hasResult)));
     MOZ_ASSERT(!hasResult);
@@ -19630,19 +19659,19 @@ CreateObjectStoreOp::DoDatabaseWork(Data
 
   DatabaseConnection::AutoSavepoint autoSave;
   nsresult rv = autoSave.Start(Transaction());
   if (NS_WARN_IF(NS_FAILED(rv))) {
     return rv;
   }
 
   DatabaseConnection::CachedStatement stmt;
-  rv = aConnection->GetCachedStatement(NS_LITERAL_CSTRING(
+  rv = aConnection->GetCachedStatement(
     "INSERT INTO object_store (id, auto_increment, name, key_path) "
-    "VALUES (:id, :auto_increment, :name, :key_path)"),
+    "VALUES (:id, :auto_increment, :name, :key_path)",
     &stmt);
   if (NS_WARN_IF(NS_FAILED(rv))) {
     return rv;
   }
 
   rv = stmt->BindInt64ByName(NS_LITERAL_CSTRING("id"), mMetadata.id());
   if (NS_WARN_IF(NS_FAILED(rv))) {
     return rv;
@@ -19708,19 +19737,19 @@ DeleteObjectStoreOp::DoDatabaseWork(Data
 
   NS_NAMED_LITERAL_CSTRING(objectStoreIdString, "object_store_id");
 
 #ifdef DEBUG
   {
     // Make sure |mIsLastObjectStore| is telling the truth.
     DatabaseConnection::CachedStatement stmt;
     MOZ_ALWAYS_TRUE(NS_SUCCEEDED(
-      aConnection->GetCachedStatement(NS_LITERAL_CSTRING(
+      aConnection->GetCachedStatement(
         "SELECT id "
-          "FROM object_store;"),
+          "FROM object_store;",
         &stmt)));
 
     bool foundThisObjectStore = false;
     bool foundOtherObjectStore = false;
 
     while (true) {
       bool hasResult;
       MOZ_ALWAYS_TRUE(NS_SUCCEEDED(stmt->ExecuteStep(&hasResult)));
@@ -19755,66 +19784,66 @@ DeleteObjectStoreOp::DoDatabaseWork(Data
   nsresult rv = autoSave.Start(Transaction());
   if (NS_WARN_IF(NS_FAILED(rv))) {
     return rv;
   }
 
   if (mIsLastObjectStore) {
     // We can just delete everything if this is the last object store.
     DatabaseConnection::CachedStatement stmt;
-    rv = aConnection->GetCachedStatement(NS_LITERAL_CSTRING(
-      "DELETE FROM index_data;"),
+    rv = aConnection->GetCachedStatement(
+      "DELETE FROM index_data;",
       &stmt);
     if (NS_WARN_IF(NS_FAILED(rv))) {
       return rv;
     }
 
     rv = stmt->Execute();
     if (NS_WARN_IF(NS_FAILED(rv))) {
       return rv;
     }
 
-    rv = aConnection->GetCachedStatement(NS_LITERAL_CSTRING(
-      "DELETE FROM unique_index_data;"),
+    rv = aConnection->GetCachedStatement(
+      "DELETE FROM unique_index_data;",
       &stmt);
     if (NS_WARN_IF(NS_FAILED(rv))) {
       return rv;
     }
 
     rv = stmt->Execute();
     if (NS_WARN_IF(NS_FAILED(rv))) {
       return rv;
     }
 
-    rv = aConnection->GetCachedStatement(NS_LITERAL_CSTRING(
-      "DELETE FROM object_data;"),
+    rv = aConnection->GetCachedStatement(
+      "DELETE FROM object_data;",
       &stmt);
     if (NS_WARN_IF(NS_FAILED(rv))) {
       return rv;
     }
 
     rv = stmt->Execute();
     if (NS_WARN_IF(NS_FAILED(rv))) {
       return rv;
     }
 
-    rv = aConnection->GetCachedStatement(NS_LITERAL_CSTRING(
-      "DELETE FROM object_store_index;"),
+    rv = aConnection->GetCachedStatement(
+      "DELETE FROM object_store_index;",
       &stmt);
     if (NS_WARN_IF(NS_FAILED(rv))) {
       return rv;
     }
 
     rv = stmt->Execute();
     if (NS_WARN_IF(NS_FAILED(rv))) {
       return rv;
     }
 
-    rv = aConnection->GetCachedStatement(NS_LITERAL_CSTRING(
-      "DELETE FROM object_store;"),
+    rv = aConnection->GetCachedStatement(
+      "DELETE FROM object_store;",
       &stmt);
     if (NS_WARN_IF(NS_FAILED(rv))) {
       return rv;
     }
 
     rv = stmt->Execute();
     if (NS_WARN_IF(NS_FAILED(rv))) {
       return rv;
@@ -19826,19 +19855,19 @@ DeleteObjectStoreOp::DoDatabaseWork(Data
         mMetadata->mCommonMetadata.id(),
         void_t());
       if (NS_WARN_IF(NS_FAILED(rv))) {
         return rv;
       }
 
       // Now clean up the object store index table.
       DatabaseConnection::CachedStatement stmt;
-      rv = aConnection->GetCachedStatement(NS_LITERAL_CSTRING(
+      rv = aConnection->GetCachedStatement(
         "DELETE FROM object_store_index "
-          "WHERE object_store_id = :object_store_id;"),
+          "WHERE object_store_id = :object_store_id;",
         &stmt);
       if (NS_WARN_IF(NS_FAILED(rv))) {
         return rv;
       }
 
       rv = stmt->BindInt64ByName(objectStoreIdString,
                                  mMetadata->mCommonMetadata.id());
       if (NS_WARN_IF(NS_FAILED(rv))) {
@@ -19848,19 +19877,19 @@ DeleteObjectStoreOp::DoDatabaseWork(Data
       rv = stmt->Execute();
       if (NS_WARN_IF(NS_FAILED(rv))) {
         return rv;
       }
     } else {
       // We only have to worry about object data if this object store has no
       // indexes.
       DatabaseConnection::CachedStatement stmt;
-      rv = aConnection->GetCachedStatement(NS_LITERAL_CSTRING(
+      rv = aConnection->GetCachedStatement(
         "DELETE FROM object_data "
-          "WHERE object_store_id = :object_store_id;"),
+          "WHERE object_store_id = :object_store_id;",
         &stmt);
       if (NS_WARN_IF(NS_FAILED(rv))) {
         return rv;
       }
 
       rv = stmt->BindInt64ByName(objectStoreIdString,
                                  mMetadata->mCommonMetadata.id());
       if (NS_WARN_IF(NS_FAILED(rv))) {
@@ -19869,19 +19898,19 @@ DeleteObjectStoreOp::DoDatabaseWork(Data
 
       rv = stmt->Execute();
       if (NS_WARN_IF(NS_FAILED(rv))) {
         return rv;
       }
     }
 
     DatabaseConnection::CachedStatement stmt;
-    rv = aConnection->GetCachedStatement(NS_LITERAL_CSTRING(
+    rv = aConnection->GetCachedStatement(
       "DELETE FROM object_store "
-        "WHERE id = :object_store_id;"),
+        "WHERE id = :object_store_id;",
       &stmt);
     if (NS_WARN_IF(NS_FAILED(rv))) {
       return rv;
     }
 
     rv = stmt->BindInt64ByName(objectStoreIdString,
                                mMetadata->mCommonMetadata.id());
     if (NS_WARN_IF(NS_FAILED(rv))) {
@@ -19993,21 +20022,21 @@ CreateIndexOp::InsertDataFromObjectStore
   MOZ_ASSERT(!IndexedDatabaseManager::InLowDiskSpaceMode());
   MOZ_ASSERT(mMaybeUniqueIndexTable);
 
   nsCOMPtr<mozIStorageConnection> storageConnection =
     aConnection->GetStorageConnection();
   MOZ_ASSERT(storageConnection);
 
   DatabaseConnection::CachedStatement stmt;
-  nsresult rv = aConnection->GetCachedStatement(NS_LITERAL_CSTRING(
+  nsresult rv = aConnection->GetCachedStatement(
     "UPDATE object_data "
       "SET index_data_values = update_index_data_values "
         "(key, index_data_values, file_ids, data) "
-      "WHERE object_store_id = :object_store_id;"),
+      "WHERE object_store_id = :object_store_id;",
     &stmt);
   if (NS_WARN_IF(NS_FAILED(rv))) {
     return rv;
   }
 
   rv = stmt->BindInt64ByName(NS_LITERAL_CSTRING("object_store_id"),
                              mObjectStoreId);
   if (NS_WARN_IF(NS_FAILED(rv))) {
@@ -20074,21 +20103,21 @@ CreateIndexOp::DoDatabaseWork(DatabaseCo
 
 #ifdef DEBUG
   {
     // Make sure that we're not creating an index with the same name and object
     // store as another that already exists. This should be impossible because
     // we should have thrown an error long before now...
     DatabaseConnection::CachedStatement stmt;
     MOZ_ALWAYS_TRUE(NS_SUCCEEDED(
-      aConnection->GetCachedStatement(NS_LITERAL_CSTRING(
+      aConnection->GetCachedStatement(
         "SELECT name "
           "FROM object_store_index "
           "WHERE object_store_id = :osid "
-          "AND name = :name;"),
+          "AND name = :name;",
         &stmt)));
     MOZ_ALWAYS_TRUE(NS_SUCCEEDED(
       stmt->BindInt64ByName(NS_LITERAL_CSTRING("osid"), mObjectStoreId)));
     MOZ_ALWAYS_TRUE(NS_SUCCEEDED(
       stmt->BindStringByName(NS_LITERAL_CSTRING("name"), mMetadata.name())));
 
     bool hasResult;
     MOZ_ALWAYS_TRUE(NS_SUCCEEDED(stmt->ExecuteStep(&hasResult)));
@@ -20099,20 +20128,20 @@ CreateIndexOp::DoDatabaseWork(DatabaseCo
 
   DatabaseConnection::AutoSavepoint autoSave;
   nsresult rv = autoSave.Start(Transaction());
   if (NS_WARN_IF(NS_FAILED(rv))) {
     return rv;
   }
 
   DatabaseConnection::CachedStatement stmt;
-  rv = aConnection->GetCachedStatement(NS_LITERAL_CSTRING(
+  rv = aConnection->GetCachedStatement(
     "INSERT INTO object_store_index (id, name, key_path, unique_index, "
                                     "multientry, object_store_id) "
-    "VALUES (:id, :name, :key_path, :unique, :multientry, :osid)"),
+    "VALUES (:id, :name, :key_path, :unique, :multientry, :osid)",
     &stmt);
   if (NS_WARN_IF(NS_FAILED(rv))) {
     return rv;
   }
 
   rv = stmt->BindInt64ByName(NS_LITERAL_CSTRING("id"), mMetadata.id());
   if (NS_WARN_IF(NS_FAILED(rv))) {
     return rv;
@@ -20504,21 +20533,21 @@ DeleteIndexOp::RemoveReferencesToIndex(
   PROFILER_LABEL("IndexedDB",
                  "DeleteIndexOp::RemoveReferencesToIndex",
                  js::ProfileEntry::Category::STORAGE);
 
   if (mIsLastIndex) {
     // There is no need to parse the previous entry in the index_data_values
     // column if this is the last index. Simply set it to NULL.
     DatabaseConnection::CachedStatement stmt;
-    nsresult rv = aConnection->GetCachedStatement(NS_LITERAL_CSTRING(
+    nsresult rv = aConnection->GetCachedStatement(
       "UPDATE object_data "
         "SET index_data_values = NULL "
         "WHERE object_store_id = :object_store_id "
-        "AND key = :key;"),
+        "AND key = :key;",
       &stmt);
     if (NS_WARN_IF(NS_FAILED(rv))) {
       return rv;
     }
 
     rv = stmt->BindInt64ByName(NS_LITERAL_CSTRING("object_store_id"),
                                mObjectStoreId);
     if (NS_WARN_IF(NS_FAILED(rv))) {
@@ -20602,20 +20631,20 @@ DeleteIndexOp::DoDatabaseWork(DatabaseCo
   MOZ_ASSERT(aConnection);
   aConnection->AssertIsOnConnectionThread();
 
 #ifdef DEBUG
   {
     // Make sure |mIsLastIndex| is telling the truth.
     DatabaseConnection::CachedStatement stmt;
     MOZ_ALWAYS_TRUE(NS_SUCCEEDED(
-      aConnection->GetCachedStatement(NS_LITERAL_CSTRING(
+      aConnection->GetCachedStatement(
         "SELECT id "
           "FROM object_store_index "
-          "WHERE object_store_id = :object_store_id;"),
+          "WHERE object_store_id = :object_store_id;",
         &stmt)));
 
     MOZ_ALWAYS_TRUE(NS_SUCCEEDED(
       stmt->BindInt64ByName(NS_LITERAL_CSTRING("object_store_id"),
                             mObjectStoreId)));
 
     bool foundThisIndex = false;
     bool foundOtherIndex = false;
@@ -20655,59 +20684,59 @@ DeleteIndexOp::DoDatabaseWork(DatabaseCo
 
   DatabaseConnection::CachedStatement selectStmt;
 
   // mozStorage warns that these statements trigger a sort operation but we
   // don't care because this is a very rare call and we expect it to be slow.
   // The cost of having an index on this field is too high.
   if (mUnique) {
     if (mIsLastIndex) {
-      rv = aConnection->GetCachedStatement(NS_LITERAL_CSTRING(
+      rv = aConnection->GetCachedStatement(
         "/* do not warn (bug someone else) */ "
         "SELECT value, object_data_key "
           "FROM unique_index_data "
           "WHERE index_id = :index_id "
-          "ORDER BY object_data_key ASC;"),
+          "ORDER BY object_data_key ASC;",
         &selectStmt);
     } else {
-      rv = aConnection->GetCachedStatement(NS_LITERAL_CSTRING(
+      rv = aConnection->GetCachedStatement(
         "/* do not warn (bug out) */ "
         "SELECT unique_index_data.value, "
                "unique_index_data.object_data_key, "
                "object_data.index_data_values "
           "FROM unique_index_data "
           "JOIN object_data "
           "ON unique_index_data.object_data_key = object_data.key "
           "WHERE unique_index_data.index_id = :index_id "
           "AND object_data.object_store_id = :object_store_id "
-          "ORDER BY unique_index_data.object_data_key ASC;"),
+          "ORDER BY unique_index_data.object_data_key ASC;",
         &selectStmt);
     }
   } else {
     if (mIsLastIndex) {
-      rv = aConnection->GetCachedStatement(NS_LITERAL_CSTRING(
+      rv = aConnection->GetCachedStatement(
         "/* do not warn (bug me not) */ "
         "SELECT value, object_data_key "
           "FROM index_data "
           "WHERE index_id = :index_id "
           "AND object_store_id = :object_store_id "
-          "ORDER BY object_data_key ASC;"),
+          "ORDER BY object_data_key ASC;",
         &selectStmt);
     } else {
-      rv = aConnection->GetCachedStatement(NS_LITERAL_CSTRING(
+      rv = aConnection->GetCachedStatement(
         "/* do not warn (bug off) */ "
         "SELECT index_data.value, "
                "index_data.object_data_key, "
                "object_data.index_data_values "
           "FROM index_data "
           "JOIN object_data "
           "ON index_data.object_data_key = object_data.key "
           "WHERE index_data.index_id = :index_id "
           "AND object_data.object_store_id = :object_store_id "
-          "ORDER BY index_data.object_data_key ASC;"),
+          "ORDER BY index_data.object_data_key ASC;",
         &selectStmt);
     }
   }
   if (NS_WARN_IF(NS_FAILED(rv))) {
     return rv;
   }
 
   NS_NAMED_LITERAL_CSTRING(indexIdString, "index_id");
@@ -20798,27 +20827,27 @@ DeleteIndexOp::DoDatabaseWork(DatabaseCo
       }
     }
 
     // Now delete the index row.
     if (deleteIndexRowStmt) {
         MOZ_ALWAYS_TRUE(NS_SUCCEEDED(deleteIndexRowStmt->Reset()));
     } else {
       if (mUnique) {
-        rv = aConnection->GetCachedStatement(NS_LITERAL_CSTRING(
+        rv = aConnection->GetCachedStatement(
           "DELETE FROM unique_index_data "
             "WHERE index_id = :index_id "
-            "AND value = :value;"),
+            "AND value = :value;",
           &deleteIndexRowStmt);
       } else {
-        rv = aConnection->GetCachedStatement(NS_LITERAL_CSTRING(
+        rv = aConnection->GetCachedStatement(
           "DELETE FROM index_data "
             "WHERE index_id = :index_id "
             "AND value = :value "
-            "AND object_data_key = :object_data_key;"),
+            "AND object_data_key = :object_data_key;",
           &deleteIndexRowStmt);
       }
       if (NS_WARN_IF(NS_FAILED(rv))) {
         return rv;
       }
     }
 
     rv = deleteIndexRowStmt->BindInt64ByName(indexIdString, mIndexId);
@@ -20856,19 +20885,19 @@ DeleteIndexOp::DoDatabaseWork(DatabaseCo
                                  lastObjectStoreKey,
                                  lastIndexValues);
     if (NS_WARN_IF(NS_FAILED(rv))) {
       return rv;
     }
   }
 
   DatabaseConnection::CachedStatement deleteStmt;
-  rv = aConnection->GetCachedStatement(NS_LITERAL_CSTRING(
+  rv = aConnection->GetCachedStatement(
     "DELETE FROM object_store_index "
-      "WHERE id = :index_id;"),
+      "WHERE id = :index_id;",
     &deleteStmt);
   if (NS_WARN_IF(NS_FAILED(rv))) {
     return rv;
   }
 
   rv = deleteStmt->BindInt64ByName(indexIdString, mIndexId);
   if (NS_WARN_IF(NS_FAILED(rv))) {
     return rv;
@@ -20990,21 +21019,21 @@ ObjectStoreAddOrPutRequestOp::RemoveOldI
 {
   AssertIsOnConnectionThread();
   MOZ_ASSERT(aConnection);
   MOZ_ASSERT(mOverwrite);
   MOZ_ASSERT(!mResponse.IsUnset());
   MOZ_ASSERT(mObjectStoreHasIndexes);
 
   DatabaseConnection::CachedStatement indexValuesStmt;
-  nsresult rv = aConnection->GetCachedStatement(NS_LITERAL_CSTRING(
+  nsresult rv = aConnection->GetCachedStatement(
     "SELECT index_data_values "
       "FROM object_data "
       "WHERE object_store_id = :object_store_id "
-      "AND key = :key;"),
+      "AND key = :key;",
     &indexValuesStmt);
   if (NS_WARN_IF(NS_FAILED(rv))) {
     return rv;
   }
 
   rv = indexValuesStmt->BindInt64ByName(NS_LITERAL_CSTRING("object_store_id"),
                                         mParams.objectStoreId());
   if (NS_WARN_IF(NS_FAILED(rv))) {
@@ -21239,26 +21268,26 @@ ObjectStoreAddOrPutRequestOp::DoDatabase
   }
 
   // The "|| keyUnset" here is mostly a debugging tool. If a key isn't
   // specified we should never have a collision and so it shouldn't matter
   // if we allow overwrite or not. By not allowing overwrite we raise
   // detectable errors rather than corrupting data.
   DatabaseConnection::CachedStatement stmt;
   if (!mOverwrite || keyUnset) {
-    rv = aConnection->GetCachedStatement(NS_LITERAL_CSTRING(
+    rv = aConnection->GetCachedStatement(
       "INSERT INTO object_data "
         "(object_store_id, key, file_ids, data) "
-        "VALUES (:osid, :key, :file_ids, :data);"),
+        "VALUES (:osid, :key, :file_ids, :data);",
       &stmt);
   } else {
-    rv = aConnection->GetCachedStatement(NS_LITERAL_CSTRING(
+    rv = aConnection->GetCachedStatement(
       "INSERT OR REPLACE INTO object_data "
         "(object_store_id, key, file_ids, data) "
-        "VALUES (:osid, :key, :file_ids, :data);"),
+        "VALUES (:osid, :key, :file_ids, :data);",
     &stmt);
   }
   if (NS_WARN_IF(NS_FAILED(rv))) {
     return rv;
   }
 
   rv = stmt->BindInt64ByName(NS_LITERAL_CSTRING("osid"), osid);
   if (NS_WARN_IF(NS_FAILED(rv))) {
@@ -22003,19 +22032,19 @@ ObjectStoreClearRequestOp::DoDatabaseWor
     rv = DeleteObjectStoreDataTableRowsWithIndexes(aConnection,
                                                    mParams.objectStoreId(),
                                                    void_t());
     if (NS_WARN_IF(NS_FAILED(rv))) {
       return rv;
     }
   } else {
     DatabaseConnection::CachedStatement stmt;
-    rv = aConnection->GetCachedStatement(NS_LITERAL_CSTRING(
+    rv = aConnection->GetCachedStatement(
       "DELETE FROM object_data "
-        "WHERE object_store_id = :object_store_id;"),
+        "WHERE object_store_id = :object_store_id;",
       &stmt);
     if (NS_WARN_IF(NS_FAILED(rv))) {
       return rv;
     }
 
     rv = stmt->BindInt64ByName(NS_LITERAL_CSTRING("object_store_id"),
                                mParams.objectStoreId());
     if (NS_WARN_IF(NS_FAILED(rv))) {
--- a/dom/quota/QuotaManager.cpp
+++ b/dom/quota/QuotaManager.cpp
@@ -106,22 +106,22 @@ static_assert(
   "Enum values should match.");
 
 namespace {
 
 const char kChromeOrigin[] = "chrome";
 const char kAboutHomeOrigin[] = "moz-safe-about:home";
 const char kIndexedDBOriginPrefix[] = "indexeddb://";
 
-#define INDEXEDDB_DIRECTORY_NAME "indexedDB"
-#define STORAGE_DIRECTORY_NAME "storage"
-#define PERSISTENT_DIRECTORY_NAME "persistent"
-#define PERMANENT_DIRECTORY_NAME "permanent"
-#define TEMPORARY_DIRECTORY_NAME "temporary"
-#define DEFAULT_DIRECTORY_NAME "default"
+const char kIndexedDBDirectoryName[] = "indexedDB";
+const char kStorageDirectoryName[] = "storage";
+const char kPersistentDirectoryName[] = "persistent";
+const char kPermanentDirectoryName[] = "permanent";
+const char kTemporaryDirectoryName[] = "temporary";
+const char kDefaultDirectoryName[] = "default";
 
 enum AppId {
   kNoAppId = nsIScriptSecurityManager::NO_APP_ID,
   kUnknownAppId = nsIScriptSecurityManager::UNKNOWN_APP_ID
 };
 
 } // anonymous namespace
 
@@ -796,28 +796,29 @@ bool
 IsTreatedAsTemporary(PersistenceType aPersistenceType,
                      bool aIsApp)
 {
   return !IsTreatedAsPersistent(aPersistenceType, aIsApp);
 }
 
 nsresult
 CloneStoragePath(nsIFile* aBaseDir,
-                 const nsAString& aStorageName,
+                 const nsACString& aStorageName,
                  nsAString& aStoragePath)
 {
   nsresult rv;
 
   nsCOMPtr<nsIFile> storageDir;
   rv = aBaseDir->Clone(getter_AddRefs(storageDir));
   if (NS_WARN_IF(NS_FAILED(rv))) {
     return rv;
   }
 
-  rv = storageDir->Append(aStorageName);
+  NS_ConvertASCIItoUTF16 dirName(aStorageName);
+  rv = storageDir->Append(dirName);
   if (NS_WARN_IF(NS_FAILED(rv))) {
     return rv;
   }
 
   rv = storageDir->GetPath(aStoragePath);
   if (NS_WARN_IF(NS_FAILED(rv))) {
     return rv;
   }
@@ -1421,38 +1422,39 @@ QuotaManager::Init()
                                 getter_AddRefs(baseDir));
     if (NS_FAILED(rv)) {
       rv = NS_GetSpecialDirectory(NS_APP_USER_PROFILE_50_DIR,
                                   getter_AddRefs(baseDir));
     }
     NS_ENSURE_SUCCESS(rv, rv);
 
     rv = CloneStoragePath(baseDir,
-                          NS_LITERAL_STRING(INDEXEDDB_DIRECTORY_NAME),
+                          NS_LITERAL_CSTRING(kIndexedDBDirectoryName),
                           mIndexedDBPath);
     NS_ENSURE_SUCCESS(rv, rv);
 
-    rv = baseDir->Append(NS_LITERAL_STRING(STORAGE_DIRECTORY_NAME));
+    NS_ConvertASCIItoUTF16 dirName(NS_LITERAL_CSTRING(kStorageDirectoryName));
+    rv = baseDir->Append(dirName);
     NS_ENSURE_SUCCESS(rv, rv);
 
     rv = baseDir->GetPath(mStoragePath);
     NS_ENSURE_SUCCESS(rv, rv);
 
     rv = CloneStoragePath(baseDir,
-                          NS_LITERAL_STRING(PERMANENT_DIRECTORY_NAME),
+                          NS_LITERAL_CSTRING(kPermanentDirectoryName),
                           mPermanentStoragePath);
     NS_ENSURE_SUCCESS(rv, rv);
 
     rv = CloneStoragePath(baseDir,
-                          NS_LITERAL_STRING(TEMPORARY_DIRECTORY_NAME),
+                          NS_LITERAL_CSTRING(kTemporaryDirectoryName),
                           mTemporaryStoragePath);
     NS_ENSURE_SUCCESS(rv, rv);
 
     rv = CloneStoragePath(baseDir,
-                          NS_LITERAL_STRING(DEFAULT_DIRECTORY_NAME),
+                          NS_LITERAL_CSTRING(kDefaultDirectoryName),
                           mDefaultStoragePath);
     NS_ENSURE_SUCCESS(rv, rv);
 
     // Make a lazy thread for any IO we need (like clearing or enumerating the
     // contents of storage directories).
     mIOThread = new LazyIdleThread(DEFAULT_THREAD_TIMEOUT_MS,
                                    NS_LITERAL_CSTRING("Storage I/O"),
                                    LazyIdleThread::ManualShutdown);
@@ -2126,17 +2128,18 @@ QuotaManager::MaybeUpgradeIndexedDBDirec
 
   nsCOMPtr<nsIFile> persistentStorageDir =
     do_CreateInstance(NS_LOCAL_FILE_CONTRACTID, &rv);
   NS_ENSURE_SUCCESS(rv, rv);
 
   rv = persistentStorageDir->InitWithPath(mStoragePath);
   NS_ENSURE_SUCCESS(rv, rv);
 
-  rv = persistentStorageDir->Append(NS_LITERAL_STRING(PERSISTENT_DIRECTORY_NAME));
+  NS_ConvertASCIItoUTF16 dirName(NS_LITERAL_CSTRING(kPersistentDirectoryName));
+  rv = persistentStorageDir->Append(dirName);
   NS_ENSURE_SUCCESS(rv, rv);
 
   rv = persistentStorageDir->Exists(&exists);
   NS_ENSURE_SUCCESS(rv, rv);
 
   if (exists) {
     NS_WARNING("indexedDB directory shouldn't exist after the upgrade!");
     return NS_OK;
@@ -2147,17 +2150,17 @@ QuotaManager::MaybeUpgradeIndexedDBDirec
   NS_ENSURE_SUCCESS(rv, rv);
 
   // MoveTo() is atomic if the move happens on the same volume which should
   // be our case, so even if we crash in the middle of the operation nothing
   // breaks next time we try to initialize.
   // However there's a theoretical possibility that the indexedDB directory
   // is on different volume, but it should be rare enough that we don't have
   // to worry about it.
-  rv = indexedDBDir->MoveTo(storageDir, NS_LITERAL_STRING(PERSISTENT_DIRECTORY_NAME));
+  rv = indexedDBDir->MoveTo(storageDir, dirName);
   NS_ENSURE_SUCCESS(rv, rv);
 
   return NS_OK;
 }
 
 nsresult
 QuotaManager::MaybeUpgradePersistentStorageDirectory()
 {
@@ -2171,17 +2174,18 @@ QuotaManager::MaybeUpgradePersistentStor
     return rv;
   }
 
   rv = persistentStorageDir->InitWithPath(mStoragePath);
   if (NS_WARN_IF(NS_FAILED(rv))) {
     return rv;
   }
 
-  rv = persistentStorageDir->Append(NS_LITERAL_STRING(PERSISTENT_DIRECTORY_NAME));
+  NS_ConvertASCIItoUTF16 dirName(NS_LITERAL_CSTRING(kPersistentDirectoryName));
+  rv = persistentStorageDir->Append(dirName);
   if (NS_WARN_IF(NS_FAILED(rv))) {
     return rv;
   }
 
   bool exists;
   rv = persistentStorageDir->Exists(&exists);
   if (NS_WARN_IF(NS_FAILED(rv))) {
     return rv;
@@ -2266,17 +2270,18 @@ QuotaManager::MaybeUpgradePersistentStor
 
     rv = helper->CreateOrUpgradeMetadataFiles(/* aCreate */ false);
     if (NS_WARN_IF(NS_FAILED(rv))) {
       return rv;
     }
   }
 
   // And finally rename persistent to default.
-  rv = persistentStorageDir->RenameTo(nullptr, NS_LITERAL_STRING(DEFAULT_DIRECTORY_NAME));
+  NS_ConvertASCIItoUTF16 defDirName(NS_LITERAL_CSTRING(kDefaultDirectoryName));
+  rv = persistentStorageDir->RenameTo(nullptr, defDirName);
   if (NS_WARN_IF(NS_FAILED(rv))) {
     return rv;
   }
 
   return NS_OK;
 }
 
 nsresult
@@ -2475,17 +2480,17 @@ QuotaManager::GetStorageId(PersistenceTy
 {
   nsAutoCString str;
   str.AppendInt(aPersistenceType);
   str.Append('*');
   str.Append(aOrigin);
   str.Append('*');
   str.AppendInt(aClientType);
   str.Append('*');
-  AppendUTF16toUTF8(aName, str);
+  str.Append(NS_ConvertUTF16toUTF8(aName));
 
   aDatabaseId = str;
 }
 
 // static
 nsresult
 QuotaManager::GetInfoFromURI(nsIURI* aURI,
                              uint32_t aAppId,
--- a/extensions/cookie/nsPermissionManager.cpp
+++ b/extensions/cookie/nsPermissionManager.cpp
@@ -351,20 +351,20 @@ nsPermissionManager::AppClearDataObserve
 {
   nsCOMPtr<nsIObserverService> observerService = do_GetService("@mozilla.org/observer-service;1");
   observerService->AddObserver(new AppClearDataObserver(), "webapps-clear-data", /* holdsWeak= */ false);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // nsPermissionManager Implementation
 
-#define PERMISSIONS_FILE_NAME "permissions.sqlite"
+static const char kPermissionsFileName[] = "permissions.sqlite";
 #define HOSTS_SCHEMA_VERSION 4
 
-#define HOSTPERM_FILE_NAME "hostperm.1"
+static const char kHostpermFileName[] = "hostperm.1";
 
 // Default permissions are read from a URL - this is the preference we read
 // to find that URL. If not set, don't use any default permissions.
 static const char kDefaultsUrlPrefName[] = "permissions.manager.defaultsUrl";
 
 static const char kPermissionChangeNotification[] = PERM_CHANGE_NOTIFICATION;
 
 NS_IMPL_ISUPPORTS(nsPermissionManager, nsIPermissionManager, nsIObserver, nsISupportsWeakReference)
@@ -448,17 +448,17 @@ nsPermissionManager::InitDB(bool aRemove
 {
   nsCOMPtr<nsIFile> permissionsFile;
   nsresult rv = NS_GetSpecialDirectory(NS_APP_PERMISSION_PARENT_DIR, getter_AddRefs(permissionsFile));
   if (NS_FAILED(rv)) {
     rv = NS_GetSpecialDirectory(NS_APP_USER_PROFILE_50_DIR, getter_AddRefs(permissionsFile));
   }
   NS_ENSURE_SUCCESS(rv, NS_ERROR_UNEXPECTED);
 
-  rv = permissionsFile->AppendNative(NS_LITERAL_CSTRING(PERMISSIONS_FILE_NAME));
+  rv = permissionsFile->AppendNative(NS_LITERAL_CSTRING(kPermissionsFileName));
   NS_ENSURE_SUCCESS(rv, rv);
 
   if (aRemoveFile) {
     bool exists = false;
     rv = permissionsFile->Exists(&exists);
     NS_ENSURE_SUCCESS(rv, rv);
     if (exists) {
       rv = permissionsFile->Remove(false);
@@ -1856,17 +1856,17 @@ nsresult
 nsPermissionManager::Import()
 {
   nsresult rv;
 
   nsCOMPtr<nsIFile> permissionsFile;
   rv = NS_GetSpecialDirectory(NS_APP_USER_PROFILE_50_DIR, getter_AddRefs(permissionsFile));
   if (NS_FAILED(rv)) return rv;
 
-  rv = permissionsFile->AppendNative(NS_LITERAL_CSTRING(HOSTPERM_FILE_NAME));
+  rv = permissionsFile->AppendNative(NS_LITERAL_CSTRING(kHostpermFileName));
   NS_ENSURE_SUCCESS(rv, rv);
 
   nsCOMPtr<nsIInputStream> fileInputStream;
   rv = NS_NewLocalFileInputStream(getter_AddRefs(fileInputStream),
                                   permissionsFile);
   NS_ENSURE_SUCCESS(rv, rv);
 
   rv = _DoImport(fileInputStream, mDBConn);
--- a/netwerk/base/Predictor.cpp
+++ b/netwerk/base/Predictor.cpp
@@ -123,17 +123,17 @@ const uint32_t ONE_MONTH = 30U * ONE_DAY
 const uint32_t ONE_YEAR = 365U * ONE_DAY;
 
 const uint32_t STARTUP_WINDOW = 5U * 60U; // 5min
 
 // Version of metadata entries we expect
 const uint32_t METADATA_VERSION = 1;
 
 // ID Extensions for cache entries
-#define PREDICTOR_ORIGIN_EXTENSION "predictor-origin"
+const char PREDICTOR_ORIGIN_EXTENSION[] = "predictor-origin";
 
 // Get the full origin (scheme, host, port) out of a URI (maybe should be part
 // of nsIURI instead?)
 static nsresult
 ExtractOrigin(nsIURI *uri, nsIURI **originUri, nsIIOService *ioService)
 {
   nsAutoCString s;
   s.Truncate();
@@ -501,26 +501,26 @@ class NuwaMarkPredictorThreadRunner : pu
     return NS_OK;
   }
 };
 } // anon namespace
 #endif
 
 // Predictor::nsICacheEntryMetaDataVisitor
 
-#define SEEN_META_DATA "predictor::seen"
-#define META_DATA_PREFIX "predictor::"
+static const char seenMetaData[] = "predictor::seen";
+static const char metaDataPrefix[] = "predictor::";
 nsresult
 Predictor::OnMetaDataElement(const char *asciiKey, const char *asciiValue)
 {
   MOZ_ASSERT(NS_IsMainThread());
 
   if (!StringBeginsWith(nsDependentCString(asciiKey),
-                        NS_LITERAL_CSTRING(META_DATA_PREFIX)) ||
-      NS_LITERAL_CSTRING(SEEN_META_DATA).Equals(asciiKey)) {
+                        NS_LITERAL_CSTRING(metaDataPrefix)) ||
+      NS_LITERAL_CSTRING(seenMetaData).Equals(asciiKey)) {
     // This isn't a bit of metadata we care about
     return NS_OK;
   }
 
   nsCString key, value;
   key.AssignASCII(asciiKey);
   value.AssignASCII(asciiValue);
   mKeysToOperateOn.AppendElement(key);
@@ -1331,20 +1331,20 @@ void
 Predictor::LearnInternal(PredictorLearnReason reason, nsICacheEntry *entry,
                          bool isNew, bool fullUri, nsIURI *targetURI,
                          nsIURI *sourceURI)
 {
   MOZ_ASSERT(NS_IsMainThread());
 
   nsCString junk;
   if (!fullUri && reason == nsINetworkPredictor::LEARN_LOAD_TOPLEVEL &&
-      NS_FAILED(entry->GetMetaDataElement(SEEN_META_DATA, getter_Copies(junk)))) {
+      NS_FAILED(entry->GetMetaDataElement(seenMetaData, getter_Copies(junk)))) {
     // This is an origin-only entry that we haven't seen before. Let's mark it
     // as seen.
-    entry->SetMetaDataElement(SEEN_META_DATA, "1");
+    entry->SetMetaDataElement(seenMetaData, "1");
 
     // Need to ensure someone else can get to the entry if necessary
     entry->MetaDataReady();
     return;
   }
 
   switch (reason) {
     case nsINetworkPredictor::LEARN_LOAD_TOPLEVEL:
@@ -1371,18 +1371,18 @@ Predictor::LearnInternal(PredictorLearnR
 NS_IMPL_ISUPPORTS(Predictor::SpaceCleaner, nsICacheEntryMetaDataVisitor)
 
 NS_IMETHODIMP
 Predictor::SpaceCleaner::OnMetaDataElement(const char *key, const char *value)
 {
   MOZ_ASSERT(NS_IsMainThread());
 
   if (!StringBeginsWith(nsDependentCString(key),
-                        NS_LITERAL_CSTRING(META_DATA_PREFIX)) ||
-      NS_LITERAL_CSTRING(SEEN_META_DATA).Equals(key)) {
+                        NS_LITERAL_CSTRING(metaDataPrefix)) ||
+      NS_LITERAL_CSTRING(seenMetaData).Equals(key)) {
     // This isn't a bit of metadata we care about
     return NS_OK;
   }
 
   nsCOMPtr<nsIURI> sanityCheck;
   uint32_t hitCount, lastHit, flags;
   bool ok = mPredictor->ParseMetaDataEntry(key, value,
                                            getter_AddRefs(sanityCheck),
@@ -1415,17 +1415,17 @@ Predictor::LearnForSubresource(nsICacheE
   nsresult rv = entry->GetLastFetched(&lastLoad);
   RETURN_IF_FAILED(rv);
 
   int32_t loadCount;
   rv = entry->GetFetchCount(&loadCount);
   RETURN_IF_FAILED(rv);
 
   nsCString key;
-  key.AssignLiteral(META_DATA_PREFIX);
+  key.AssignASCII(metaDataPrefix);
   nsCString uri;
   targetURI->GetAsciiSpec(uri);
   key.Append(uri);
 
   nsCString value;
   rv = entry->GetMetaDataElement(key.BeginReading(), getter_Copies(value));
 
   uint32_t hitCount, lastHit, flags;
@@ -1549,17 +1549,17 @@ Predictor::ParseMetaDataEntry(const char
   lastHit = static_cast<uint32_t>(atoi(value));
   PREDICTOR_LOG(("    lastHit -> %u", lastHit));
 
   value = comma + 1;
   flags = static_cast<uint32_t>(atoi(value));
   PREDICTOR_LOG(("    flags -> %u", flags));
 
   if (key) {
-    const char *uriStart = key + (sizeof(META_DATA_PREFIX) - 1);
+    const char *uriStart = key + (sizeof(metaDataPrefix) - 1);
     nsresult rv = NS_NewURI(uri, uriStart, nullptr, mIOService);
     if (NS_FAILED(rv)) {
       PREDICTOR_LOG(("    NS_NewURI returned 0x%X", rv));
       return false;
     }
     PREDICTOR_LOG(("    uri -> %s", uriStart));
   }
 
@@ -1647,17 +1647,17 @@ Predictor::Resetter::OnCacheEntryAvailab
 
 NS_IMETHODIMP
 Predictor::Resetter::OnMetaDataElement(const char *asciiKey,
                                        const char *asciiValue)
 {
   MOZ_ASSERT(NS_IsMainThread());
 
   if (!StringBeginsWith(nsDependentCString(asciiKey),
-                        NS_LITERAL_CSTRING(META_DATA_PREFIX))) {
+                        NS_LITERAL_CSTRING(metaDataPrefix))) {
     // Not a metadata entry we care about, carry on
     return NS_OK;
   }
 
   nsCString key;
   key.AssignASCII(asciiKey);
   mKeysToDelete.AppendElement(key);
 
--- a/netwerk/cache2/CacheFileContextEvictor.cpp
+++ b/netwerk/cache2/CacheFileContextEvictor.cpp
@@ -15,19 +15,19 @@
 #include "nsISimpleEnumerator.h"
 #include "nsIDirectoryEnumerator.h"
 #include "mozilla/Base64.h"
 
 
 namespace mozilla {
 namespace net {
 
-#define CONTEXT_EVICTION_PREFIX "ce_"
+const char kContextEvictionPrefix[] = "ce_";
 const uint32_t kContextEvictionPrefixLength =
-  sizeof(CONTEXT_EVICTION_PREFIX) - 1;
+  sizeof(kContextEvictionPrefix) - 1;
 
 bool CacheFileContextEvictor::sDiskAlreadySearched = false;
 
 CacheFileContextEvictor::CacheFileContextEvictor()
   : mEvicting(false)
   , mIndexIsUpToDate(false)
 {
   LOG(("CacheFileContextEvictor::CacheFileContextEvictor() [this=%p]", this));
@@ -51,17 +51,17 @@ CacheFileContextEvictor::Init(nsIFile *a
 
   mCacheDirectory = aCacheDirectory;
 
   rv = aCacheDirectory->Clone(getter_AddRefs(mEntriesDir));
   if (NS_WARN_IF(NS_FAILED(rv))) {
     return rv;
   }
 
-  rv = mEntriesDir->AppendNative(NS_LITERAL_CSTRING(ENTRIES_DIR));
+  rv = mEntriesDir->AppendNative(NS_LITERAL_CSTRING(kEntriesDir));
   if (NS_WARN_IF(NS_FAILED(rv))) {
     return rv;
   }
 
   if (!sDiskAlreadySearched) {
     LoadEvictInfoFromDisk();
     if ((mEntries.Length() != 0) && mIndexIsUpToDate) {
       CreateIterators();
@@ -341,17 +341,17 @@ CacheFileContextEvictor::LoadEvictInfoFr
            "GetNativeLeafName() failed! Skipping file."));
       continue;
     }
 
     if (leaf.Length() < kContextEvictionPrefixLength) {
       continue;
     }
 
-    if (!StringBeginsWith(leaf, NS_LITERAL_CSTRING(CONTEXT_EVICTION_PREFIX))) {
+    if (!StringBeginsWith(leaf, NS_LITERAL_CSTRING(kContextEvictionPrefix))) {
       continue;
     }
 
     nsAutoCString encoded;
     encoded = Substring(leaf, kContextEvictionPrefixLength);
     encoded.ReplaceChar('-', '/');
 
     nsAutoCString decoded;
@@ -390,17 +390,17 @@ CacheFileContextEvictor::LoadEvictInfoFr
 
 nsresult
 CacheFileContextEvictor::GetContextFile(nsILoadContextInfo *aLoadContextInfo,
                                         nsIFile **_retval)
 {
   nsresult rv;
 
   nsAutoCString leafName;
-  leafName.AssignLiteral(CONTEXT_EVICTION_PREFIX);
+  leafName.Assign(NS_LITERAL_CSTRING(kContextEvictionPrefix));
 
   nsAutoCString keyPrefix;
   CacheFileUtils::AppendKeyPrefix(aLoadContextInfo, keyPrefix);
 
   nsAutoCString data64;
   rv = Base64Encode(keyPrefix, data64);
   if (NS_WARN_IF(NS_FAILED(rv))) {
     return rv;
--- a/netwerk/cache2/CacheFileIOManager.cpp
+++ b/netwerk/cache2/CacheFileIOManager.cpp
@@ -2797,32 +2797,32 @@ CacheFileIOManager::EvictAllInternal()
   }
 
   nsCOMPtr<nsIFile> file;
   rv = mCacheDirectory->Clone(getter_AddRefs(file));
   if (NS_WARN_IF(NS_FAILED(rv))) {
     return rv;
   }
 
-  rv = file->AppendNative(NS_LITERAL_CSTRING(ENTRIES_DIR));
+  rv = file->AppendNative(NS_LITERAL_CSTRING(kEntriesDir));
   if (NS_WARN_IF(NS_FAILED(rv))) {
     return rv;
   }
 
   // Trash current entries directory
   rv = TrashDirectory(file);
   if (NS_WARN_IF(NS_FAILED(rv))) {
     return rv;
   }
 
   // Files are now inaccessible in entries directory, notify observers.
   NS_DispatchToMainThread(r);
 
   // Create a new empty entries directory
-  rv = CheckAndCreateDir(mCacheDirectory, ENTRIES_DIR, false);
+  rv = CheckAndCreateDir(mCacheDirectory, kEntriesDir, false);
   if (NS_WARN_IF(NS_FAILED(rv))) {
     return rv;
   }
 
   CacheIndex::RemoveAll();
 
   return NS_OK;
 }
@@ -3008,17 +3008,17 @@ CacheFileIOManager::TrashDirectory(nsIFi
   rv = aFile->Clone(getter_AddRefs(dir));
   NS_ENSURE_SUCCESS(rv, rv);
 
   rv = aFile->Clone(getter_AddRefs(trash));
   NS_ENSURE_SUCCESS(rv, rv);
 
   srand(static_cast<unsigned>(PR_Now()));
   while (true) {
-    leaf = TRASH_DIR;
+    leaf = kTrashDir;
     leaf.AppendInt(rand());
     rv = trash->SetNativeLeafName(leaf);
     NS_ENSURE_SUCCESS(rv, rv);
 
     bool exists;
     if (NS_SUCCEEDED(trash->Exists(&exists)) && !exists) {
       break;
     }
@@ -3251,21 +3251,21 @@ CacheFileIOManager::FindTrashDirToRemove
     }
 
     nsAutoCString leafName;
     rv = file->GetNativeLeafName(leafName);
     if (NS_FAILED(rv)) {
       continue;
     }
 
-    if (leafName.Length() < strlen(TRASH_DIR)) {
+    if (leafName.Length() < strlen(kTrashDir)) {
       continue;
     }
 
-    if (!StringBeginsWith(leafName, NS_LITERAL_CSTRING(TRASH_DIR))) {
+    if (!StringBeginsWith(leafName, NS_LITERAL_CSTRING(kTrashDir))) {
       continue;
     }
 
     if (mFailedTrashDirs.Contains(leafName)) {
       continue;
     }
 
     LOG(("CacheFileIOManager::FindTrashDirToRemove() - Returning directory %s",
@@ -3417,17 +3417,17 @@ CacheFileIOManager::StrToHash(const nsAC
 nsresult
 CacheFileIOManager::GetFile(const SHA1Sum::Hash *aHash, nsIFile **_retval)
 {
   nsresult rv;
   nsCOMPtr<nsIFile> file;
   rv = mCacheDirectory->Clone(getter_AddRefs(file));
   NS_ENSURE_SUCCESS(rv, rv);
 
-  rv = file->AppendNative(NS_LITERAL_CSTRING(ENTRIES_DIR));
+  rv = file->AppendNative(NS_LITERAL_CSTRING(kEntriesDir));
   NS_ENSURE_SUCCESS(rv, rv);
 
   nsAutoCString leafName;
   HashToStr(aHash, leafName);
 
   rv = file->AppendNative(leafName);
   NS_ENSURE_SUCCESS(rv, rv);
 
@@ -3453,17 +3453,17 @@ CacheFileIOManager::GetSpecialFile(const
 nsresult
 CacheFileIOManager::GetDoomedFile(nsIFile **_retval)
 {
   nsresult rv;
   nsCOMPtr<nsIFile> file;
   rv = mCacheDirectory->Clone(getter_AddRefs(file));
   NS_ENSURE_SUCCESS(rv, rv);
 
-  rv = file->AppendNative(NS_LITERAL_CSTRING(DOOMED_DIR));
+  rv = file->AppendNative(NS_LITERAL_CSTRING(kDoomedDir));
   NS_ENSURE_SUCCESS(rv, rv);
 
   rv = file->AppendNative(NS_LITERAL_CSTRING("dummyleaf"));
   NS_ENSURE_SUCCESS(rv, rv);
 
   srand(static_cast<unsigned>(PR_Now()));
   nsAutoCString leafName;
   uint32_t iter=0;
@@ -3581,21 +3581,21 @@ CacheFileIOManager::CreateCacheTree()
   rv = CheckAndCreateDir(parentDir, nullptr, false);
   NS_ENSURE_SUCCESS(rv, rv);
 
   // ensure cache directory exists
   rv = CheckAndCreateDir(mCacheDirectory, nullptr, false);
   NS_ENSURE_SUCCESS(rv, rv);
 
   // ensure entries directory exists
-  rv = CheckAndCreateDir(mCacheDirectory, ENTRIES_DIR, false);
+  rv = CheckAndCreateDir(mCacheDirectory, kEntriesDir, false);
   NS_ENSURE_SUCCESS(rv, rv);
 
   // ensure doomed directory exists
-  rv = CheckAndCreateDir(mCacheDirectory, DOOMED_DIR, true);
+  rv = CheckAndCreateDir(mCacheDirectory, kDoomedDir, true);
   NS_ENSURE_SUCCESS(rv, rv);
 
   mTreeCreated = true;
 
   if (!mContextEvictor) {
     nsRefPtr<CacheFileContextEvictor> contextEvictor;
     contextEvictor = new CacheFileContextEvictor();
 
@@ -3777,18 +3777,18 @@ CacheFileIOManager::SyncRemoveDir(nsIFil
 
 void
 CacheFileIOManager::SyncRemoveAllCacheFiles()
 {
   LOG(("CacheFileIOManager::SyncRemoveAllCacheFiles()"));
 
   nsresult rv;
 
-  SyncRemoveDir(mCacheDirectory, ENTRIES_DIR);
-  SyncRemoveDir(mCacheDirectory, DOOMED_DIR);
+  SyncRemoveDir(mCacheDirectory, kEntriesDir);
+  SyncRemoveDir(mCacheDirectory, kDoomedDir);
 
   // Clear any intermediate state of trash dir enumeration.
   mFailedTrashDirs.Clear();
   mTrashDir = nullptr;
 
   while (true) {
     // FindTrashDirToRemove() fills mTrashDir if there is any trash directory.
     rv = FindTrashDirToRemove();
--- a/netwerk/cache2/CacheFileIOManager.h
+++ b/netwerk/cache2/CacheFileIOManager.h
@@ -27,19 +27,19 @@ class nsILoadContextInfo;
 namespace mozilla {
 namespace net {
 
 class CacheFile;
 #ifdef DEBUG_HANDLES
 class CacheFileHandlesEntry;
 #endif
 
-#define ENTRIES_DIR "entries"
-#define DOOMED_DIR  "doomed"
-#define TRASH_DIR   "trash"
+const char kEntriesDir[] = "entries";
+const char kDoomedDir[]  = "doomed";
+const char kTrashDir[]   = "trash";
 
 
 class CacheFileHandle : public nsISupports
 {
 public:
   NS_DECL_THREADSAFE_ISUPPORTS
   bool DispatchRelease();
 
--- a/netwerk/cache2/CacheIndex.cpp
+++ b/netwerk/cache2/CacheIndex.cpp
@@ -23,19 +23,19 @@
 
 
 #define kMinUnwrittenChanges   300
 #define kMinDumpInterval       20000 // in milliseconds
 #define kMaxBufSize            16384
 #define kIndexVersion          0x00000001
 #define kUpdateIndexStartDelay 50000 // in milliseconds
 
-#define INDEX_NAME      "index"
-#define TEMP_INDEX_NAME "index.tmp"
-#define JOURNAL_NAME    "index.log"
+const char kIndexName[]     = "index";
+const char kTempIndexName[] = "index.tmp";
+const char kJournalName[]   = "index.log";
 
 namespace mozilla {
 namespace net {
 
 /**
  * This helper class is responsible for keeping CacheIndex::mIndexStats and
  * CacheIndex::mFrecencyArray up to date.
  */
@@ -1034,17 +1034,17 @@ CacheIndex::RemoveAll()
 
     // Doom index and journal handles but don't null them out since this will be
     // done in FinishWrite/FinishRead methods.
     if (index->mIndexHandle) {
       CacheFileIOManager::DoomFile(index->mIndexHandle, nullptr);
     } else {
       // We don't have a handle to index file, so get the file here, but delete
       // it outside the lock. Ignore the result since this is not fatal.
-      index->GetFile(NS_LITERAL_CSTRING(INDEX_NAME), getter_AddRefs(file));
+      index->GetFile(NS_LITERAL_CSTRING(kIndexName), getter_AddRefs(file));
     }
 
     if (index->mJournalHandle) {
       CacheFileIOManager::DoomFile(index->mJournalHandle, nullptr);
     }
 
     switch (index->mState) {
       case WRITING:
@@ -1567,17 +1567,17 @@ CacheIndex::WriteIndexToDisk()
   MOZ_ASSERT(!mRWBuf);
   MOZ_ASSERT(!mRWHash);
 
   ChangeState(WRITING);
 
   mProcessEntries = mIndexStats.ActiveEntriesCount();
 
   mIndexFileOpener = new FileOpenHelper(this);
-  rv = CacheFileIOManager::OpenFile(NS_LITERAL_CSTRING(TEMP_INDEX_NAME),
+  rv = CacheFileIOManager::OpenFile(NS_LITERAL_CSTRING(kTempIndexName),
                                     CacheFileIOManager::SPECIAL_FILE |
                                     CacheFileIOManager::CREATE,
                                     mIndexFileOpener);
   if (NS_FAILED(rv)) {
     LOG(("CacheIndex::WriteIndexToDisk() - Can't open file [rv=0x%08x]", rv));
     FinishWrite(false);
     return;
   }
@@ -1818,19 +1818,19 @@ CacheIndex::RemoveFile(const nsACString 
   return NS_OK;
 }
 
 void
 CacheIndex::RemoveIndexFromDisk()
 {
   LOG(("CacheIndex::RemoveIndexFromDisk()"));
 
-  RemoveFile(NS_LITERAL_CSTRING(INDEX_NAME));
-  RemoveFile(NS_LITERAL_CSTRING(TEMP_INDEX_NAME));
-  RemoveFile(NS_LITERAL_CSTRING(JOURNAL_NAME));
+  RemoveFile(NS_LITERAL_CSTRING(kIndexName));
+  RemoveFile(NS_LITERAL_CSTRING(kTempIndexName));
+  RemoveFile(NS_LITERAL_CSTRING(kJournalName));
 }
 
 class WriteLogHelper
 {
 public:
   explicit WriteLogHelper(PRFileDesc *aFD)
     : mStatus(NS_OK)
     , mFD(aFD)
@@ -1935,24 +1935,24 @@ CacheIndex::WriteLogToDisk()
 {
   LOG(("CacheIndex::WriteLogToDisk()"));
 
   nsresult rv;
 
   MOZ_ASSERT(mPendingUpdates.Count() == 0);
   MOZ_ASSERT(mState == SHUTDOWN);
 
-  RemoveFile(NS_LITERAL_CSTRING(TEMP_INDEX_NAME));
+  RemoveFile(NS_LITERAL_CSTRING(kTempIndexName));
 
   nsCOMPtr<nsIFile> indexFile;
-  rv = GetFile(NS_LITERAL_CSTRING(INDEX_NAME), getter_AddRefs(indexFile));
+  rv = GetFile(NS_LITERAL_CSTRING(kIndexName), getter_AddRefs(indexFile));
   NS_ENSURE_SUCCESS(rv, rv);
 
   nsCOMPtr<nsIFile> logFile;
-  rv = GetFile(NS_LITERAL_CSTRING(JOURNAL_NAME), getter_AddRefs(logFile));
+  rv = GetFile(NS_LITERAL_CSTRING(kJournalName), getter_AddRefs(logFile));
   NS_ENSURE_SUCCESS(rv, rv);
 
   mIndexStats.Log();
 
   PRFileDesc *fd = nullptr;
   rv = logFile->OpenNSPRFileDesc(PR_RDWR | PR_CREATE_FILE | PR_TRUNCATE,
                                  0600, &fd);
   NS_ENSURE_SUCCESS(rv, rv);
@@ -2012,46 +2012,46 @@ CacheIndex::ReadIndexFromDisk()
   nsresult rv;
 
   AssertOwnsLock();
   MOZ_ASSERT(mState == INITIAL);
 
   ChangeState(READING);
 
   mIndexFileOpener = new FileOpenHelper(this);
-  rv = CacheFileIOManager::OpenFile(NS_LITERAL_CSTRING(INDEX_NAME),
+  rv = CacheFileIOManager::OpenFile(NS_LITERAL_CSTRING(kIndexName),
                                     CacheFileIOManager::SPECIAL_FILE |
                                     CacheFileIOManager::OPEN,
                                     mIndexFileOpener);
   if (NS_FAILED(rv)) {
     LOG(("CacheIndex::ReadIndexFromDisk() - CacheFileIOManager::OpenFile() "
-         "failed [rv=0x%08x, file=%s]", rv, INDEX_NAME));
+         "failed [rv=0x%08x, file=%s]", rv, kIndexName));
     FinishRead(false);
     return;
   }
 
   mJournalFileOpener = new FileOpenHelper(this);
-  rv = CacheFileIOManager::OpenFile(NS_LITERAL_CSTRING(JOURNAL_NAME),
+  rv = CacheFileIOManager::OpenFile(NS_LITERAL_CSTRING(kJournalName),
                                     CacheFileIOManager::SPECIAL_FILE |
                                     CacheFileIOManager::OPEN,
                                     mJournalFileOpener);
   if (NS_FAILED(rv)) {
     LOG(("CacheIndex::ReadIndexFromDisk() - CacheFileIOManager::OpenFile() "
-         "failed [rv=0x%08x, file=%s]", rv, JOURNAL_NAME));
+         "failed [rv=0x%08x, file=%s]", rv, kJournalName));
     FinishRead(false);
   }
 
   mTmpFileOpener = new FileOpenHelper(this);
-  rv = CacheFileIOManager::OpenFile(NS_LITERAL_CSTRING(TEMP_INDEX_NAME),
+  rv = CacheFileIOManager::OpenFile(NS_LITERAL_CSTRING(kTempIndexName),
                                     CacheFileIOManager::SPECIAL_FILE |
                                     CacheFileIOManager::OPEN,
                                     mTmpFileOpener);
   if (NS_FAILED(rv)) {
     LOG(("CacheIndex::ReadIndexFromDisk() - CacheFileIOManager::OpenFile() "
-         "failed [rv=0x%08x, file=%s]", rv, TEMP_INDEX_NAME));
+         "failed [rv=0x%08x, file=%s]", rv, kTempIndexName));
     FinishRead(false);
   }
 }
 
 void
 CacheIndex::StartReadingIndex()
 {
   LOG(("CacheIndex::StartReadingIndex()"));
@@ -2420,18 +2420,18 @@ CacheIndex::FinishRead(bool aSucceeded)
     // -> rebuild
     (!aSucceeded && !mIndexOnDiskIsValid && !mJournalReadSuccessfully) ||
     // -> update
     (!aSucceeded && mIndexOnDiskIsValid && !mJournalReadSuccessfully) ||
     // -> ready
     (aSucceeded && mIndexOnDiskIsValid && mJournalReadSuccessfully));
 
   if (mState == SHUTDOWN) {
-    RemoveFile(NS_LITERAL_CSTRING(TEMP_INDEX_NAME));
-    RemoveFile(NS_LITERAL_CSTRING(JOURNAL_NAME));
+    RemoveFile(NS_LITERAL_CSTRING(kTempIndexName));
+    RemoveFile(NS_LITERAL_CSTRING(kJournalName));
   } else {
     if (mIndexHandle && !mIndexOnDiskIsValid) {
       CacheFileIOManager::DoomFile(mIndexHandle, nullptr);
     }
 
     if (mJournalHandle) {
       CacheFileIOManager::DoomFile(mJournalHandle, nullptr);
     }
@@ -2566,17 +2566,17 @@ CacheIndex::SetupDirectoryEnumerator()
   MOZ_ASSERT(!mDirEnumerator);
 
   nsresult rv;
   nsCOMPtr<nsIFile> file;
 
   rv = mCacheDirectory->Clone(getter_AddRefs(file));
   NS_ENSURE_SUCCESS(rv, rv);
 
-  rv = file->AppendNative(NS_LITERAL_CSTRING(ENTRIES_DIR));
+  rv = file->AppendNative(NS_LITERAL_CSTRING(kEntriesDir));
   NS_ENSURE_SUCCESS(rv, rv);
 
   bool exists;
   rv = file->Exists(&exists);
   NS_ENSURE_SUCCESS(rv, rv);
 
   if (!exists) {
     NS_WARNING("CacheIndex::SetupDirectoryEnumerator() - Entries directory "
@@ -3362,27 +3362,27 @@ CacheIndex::OnFileOpenedInternal(FileOpe
 
       if (mTmpHandle) {
         CacheFileIOManager::DoomFile(mTmpHandle, nullptr);
         mTmpHandle = nullptr;
 
         if (mJournalHandle) { // this shouldn't normally happen
           LOG(("CacheIndex::OnFileOpenedInternal() - Unexpected state, all "
                "files [%s, %s, %s] should never exist. Removing whole index.",
-               INDEX_NAME, JOURNAL_NAME, TEMP_INDEX_NAME));
+               kIndexName, kJournalName, kTempIndexName));
           FinishRead(false);
           break;
         }
       }
 
       if (mJournalHandle) {
         // Rename journal to make sure we update index on next start in case
         // firefox crashes
         rv = CacheFileIOManager::RenameFile(
-          mJournalHandle, NS_LITERAL_CSTRING(TEMP_INDEX_NAME), this);
+          mJournalHandle, NS_LITERAL_CSTRING(kTempIndexName), this);
         if (NS_FAILED(rv)) {
           LOG(("CacheIndex::OnFileOpenedInternal() - CacheFileIOManager::"
                "RenameFile() failed synchronously [rv=0x%08x]", rv));
           FinishRead(false);
           break;
         }
       } else {
         StartReadingIndex();
@@ -3430,17 +3430,17 @@ CacheIndex::OnDataWritten(CacheFileHandl
         break;
       }
 
       if (NS_FAILED(aResult)) {
         FinishWrite(false);
       } else {
         if (mSkipEntries == mProcessEntries) {
           rv = CacheFileIOManager::RenameFile(mIndexHandle,
-                                              NS_LITERAL_CSTRING(INDEX_NAME),
+                                              NS_LITERAL_CSTRING(kIndexName),
                                               this);
           if (NS_FAILED(rv)) {
             LOG(("CacheIndex::OnDataWritten() - CacheFileIOManager::"
                  "RenameFile() failed synchronously [rv=0x%08x]", rv));
             FinishWrite(false);
           }
         } else {
           WriteRecords();
--- a/netwerk/cookie/nsCookieService.cpp
+++ b/netwerk/cookie/nsCookieService.cpp
@@ -63,17 +63,17 @@ using namespace mozilla::net;
  * nsCookieService impl:
  * useful types & constants
  ******************************************************************************/
 
 static nsCookieService *gCookieService;
 
 // XXX_hack. See bug 178993.
 // This is a hack to hide HttpOnly cookies from older browsers
-#define HTTP_ONLY_PREFIX "#HttpOnly_"
+static const char kHttpOnlyPrefix[] = "#HttpOnly_";
 
 #define COOKIES_FILE "cookies.sqlite"
 #define COOKIES_SCHEMA_VERSION 5
 
 // parameter indexes; see EnsureReadDomain, EnsureReadComplete and
 // ReadCookieDBListener::HandleResult
 #define IDX_NAME 0
 #define IDX_VALUE 1
@@ -87,17 +87,17 @@ static nsCookieService *gCookieService;
 #define IDX_BASE_DOMAIN 9
 #define IDX_APP_ID 10
 #define IDX_BROWSER_ELEM 11
 
 static const int64_t kCookieStaleThreshold = 60 * PR_USEC_PER_SEC; // 1 minute in microseconds
 static const int64_t kCookiePurgeAge =
   int64_t(30 * 24 * 60 * 60) * PR_USEC_PER_SEC; // 30 days in microseconds
 
-#define OLD_COOKIE_FILE_NAME "cookies.txt"
+static const char kOldCookieFileName[] = "cookies.txt";
 
 #undef  LIMIT
 #define LIMIT(x, low, high, default) ((x) >= (low) && (x) <= (high) ? (x) : (default))
 
 #undef  ADD_TEN_PERCENT
 #define ADD_TEN_PERCENT(i) static_cast<uint32_t>((i) + (i)/10)
 
 // default limits for the cookie list. these can be tuned by the
@@ -1232,17 +1232,17 @@ nsCookieService::TryInitDB(bool aRecreat
     getter_AddRefs(oldCookieFile));
   if (NS_FAILED(rv)) return RESULT_OK;
 
   // Import cookies, and clean up the old file regardless of success or failure.
   // Note that we have to switch out our DBState temporarily, in case we're in
   // private browsing mode; otherwise ImportCookies() won't be happy.
   DBState* initialState = mDBState;
   mDBState = mDefaultDBState;
-  oldCookieFile->AppendNative(NS_LITERAL_CSTRING(OLD_COOKIE_FILE_NAME));
+  oldCookieFile->AppendNative(NS_LITERAL_CSTRING(kOldCookieFileName));
   ImportCookies(oldCookieFile);
   oldCookieFile->Remove(false);
   mDBState = initialState;
 
   return RESULT_OK;
 }
 
 // Sets the schema version and creates the moz_cookies table.
@@ -2496,19 +2496,19 @@ nsCookieService::ImportCookies(nsIFile *
   // We will likely be adding a bunch of cookies to the DB, so we use async
   // batching with storage to make this super fast.
   nsCOMPtr<mozIStorageBindingParamsArray> paramsArray;
   if (originalCookieCount == 0 && mDefaultDBState->dbConn) {
     mDefaultDBState->stmtInsert->NewBindingParamsArray(getter_AddRefs(paramsArray));
   }
 
   while (isMore && NS_SUCCEEDED(lineInputStream->ReadLine(buffer, &isMore))) {
-    if (StringBeginsWith(buffer, NS_LITERAL_CSTRING(HTTP_ONLY_PREFIX))) {
+    if (StringBeginsWith(buffer, NS_LITERAL_CSTRING(kHttpOnlyPrefix))) {
       isHttpOnly = true;
-      hostIndex = sizeof(HTTP_ONLY_PREFIX) - 1;
+      hostIndex = sizeof(kHttpOnlyPrefix) - 1;
     } else if (buffer.IsEmpty() || buffer.First() == '#') {
       continue;
     } else {
       isHttpOnly = false;
       hostIndex = 0;
     }
 
     // this is a cheap, cheesy way of parsing a tab-delimited line into
--- a/netwerk/ipc/RemoteOpenFileChild.cpp
+++ b/netwerk/ipc/RemoteOpenFileChild.cpp
@@ -607,22 +607,16 @@ RemoteOpenFileChild::MoveToNative(nsIFil
 
 NS_IMETHODIMP
 RemoteOpenFileChild::RenameTo(nsIFile *newParentDir, const nsAString &newName)
 {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-RemoteOpenFileChild::RenameToNative(nsIFile *newParentDir, const nsACString &newName)
-{
-  return NS_ERROR_NOT_IMPLEMENTED;
-}
-
-NS_IMETHODIMP
 RemoteOpenFileChild::Remove(bool recursive)
 {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
 RemoteOpenFileChild::GetPermissions(uint32_t *aPermissions)
 {
--- a/security/manager/ssl/src/CryptoTask.h
+++ b/security/manager/ssl/src/CryptoTask.h
@@ -45,17 +45,17 @@ class CryptoTask : public nsRunnable,
                    public nsNSSShutDownObject
 {
 public:
   template <size_t LEN>
   nsresult Dispatch(const char (&taskThreadName)[LEN])
   {
     static_assert(LEN <= 15,
                   "Thread name must be no more than 15 characters");
-    return Dispatch(nsDependentCString(taskThreadName, LEN - 1));
+    return Dispatch(NS_LITERAL_CSTRING(taskThreadName));
   }
 
   nsresult Dispatch(const nsACString& taskThreadName);
 
   void Skip()
   {
     virtualDestroyNSSReference();
   }
--- a/security/manager/ssl/src/nsCertOverrideService.cpp
+++ b/security/manager/ssl/src/nsCertOverrideService.cpp
@@ -24,17 +24,17 @@
 #include "nsStreamUtils.h"
 #include "nsStringBuffer.h"
 #include "nsThreadUtils.h"
 #include "ssl.h" // For SSL_ClearSessionCache
 
 using namespace mozilla;
 using namespace mozilla::psm;
 
-#define CERT_OVERRIDE_FILE_NAME "cert_override.txt"
+static const char kCertOverrideFileName[] = "cert_override.txt";
 
 void
 nsCertOverride::convertBitsToString(OverrideBits ob, nsACString &str)
 {
   str.Truncate();
 
   if (ob & ob_Mismatch)
     str.Append('M');
@@ -139,17 +139,17 @@ nsCertOverrideService::Observe(nsISuppor
     // The profile has already changed.
     // Now read from the new profile location.
     // we also need to update the cached file location
 
     ReentrantMonitorAutoEnter lock(monitor);
 
     nsresult rv = NS_GetSpecialDirectory(NS_APP_USER_PROFILE_50_DIR, getter_AddRefs(mSettingsFile));
     if (NS_SUCCEEDED(rv)) {
-      mSettingsFile->AppendNative(NS_LITERAL_CSTRING(CERT_OVERRIDE_FILE_NAME));
+      mSettingsFile->AppendNative(NS_LITERAL_CSTRING(kCertOverrideFileName));
     } else {
       mSettingsFile = nullptr;
     }
     Read();
     CountPermanentOverrideTelemetry();
   }
 
   return NS_OK;
--- a/startupcache/StartupCache.cpp
+++ b/startupcache/StartupCache.cpp
@@ -76,17 +76,17 @@ StartupCache::CollectReports(nsIHandleRe
   REPORT("explicit/startup-cache/data", KIND_HEAP,
          HeapSizeOfIncludingThis(StartupCacheMallocSizeOf),
          "Memory used by the startup cache for things other than the file "
          "mapping.");
 
   return NS_OK;
 }
 
-#define STARTUP_CACHE_NAME "startupCache." SC_WORDSIZE "." SC_ENDIAN
+static const char sStartupCacheName[] = "startupCache." SC_WORDSIZE "." SC_ENDIAN;
 
 StartupCache*
 StartupCache::GetSingleton()
 {
   if (!gStartupCache) {
     if (XRE_GetProcessType() != GeckoProcessType_Default) {
       return nullptr;
     }
@@ -191,17 +191,17 @@ StartupCache::Init()
     rv = file->AppendNative(NS_LITERAL_CSTRING("startupCache"));
     NS_ENSURE_SUCCESS(rv, rv);
 
     // Try to create the directory if it's not there yet
     rv = file->Create(nsIFile::DIRECTORY_TYPE, 0777);
     if (NS_FAILED(rv) && rv != NS_ERROR_FILE_ALREADY_EXISTS)
       return rv;
 
-    rv = file->AppendNative(NS_LITERAL_CSTRING(STARTUP_CACHE_NAME));
+    rv = file->AppendNative(NS_LITERAL_CSTRING(sStartupCacheName));
 
     NS_ENSURE_SUCCESS(rv, rv);
 
     mFile = do_QueryInterface(file);
   }
 
   NS_ENSURE_TRUE(mFile, NS_ERROR_UNEXPECTED);
 
--- a/toolkit/components/places/nsPlacesMacros.h
+++ b/toolkit/components/places/nsPlacesMacros.h
@@ -41,17 +41,17 @@
       _sInstance = nullptr;                                                    \
       return nullptr;                                                          \
     }                                                                          \
     return ret.forget();                                                       \
   }
 
 #define PLACES_WARN_DEPRECATED()                                               \
   PR_BEGIN_MACRO                                                               \
-  nsCString msg(__FUNCTION__);                                                 \
+  nsCString msg = NS_LITERAL_CSTRING(__FUNCTION__);                            \
   msg.AppendLiteral(" is deprecated and will be removed in the next version.");\
   NS_WARNING(msg.get());                                                       \
   nsCOMPtr<nsIConsoleService> cs = do_GetService(NS_CONSOLESERVICE_CONTRACTID);\
   if (cs) {                                                                    \
     nsCOMPtr<nsIScriptError> e = do_CreateInstance(NS_SCRIPTERROR_CONTRACTID); \
     if (e && NS_SUCCEEDED(e->Init(NS_ConvertUTF8toUTF16(msg), EmptyString(),   \
                                   EmptyString(), 0, 0,                         \
                                   nsIScriptError::errorFlag, "Places"))) {     \
--- a/toolkit/components/telemetry/Telemetry.cpp
+++ b/toolkit/components/telemetry/Telemetry.cpp
@@ -79,18 +79,20 @@ using namespace mozilla::HangMonitor;
 
 using base::BooleanHistogram;
 using base::CountHistogram;
 using base::FlagHistogram;
 using base::Histogram;
 using base::LinearHistogram;
 using base::StatisticsRecorder;
 
-#define KEYED_HISTOGRAM_NAME_SEPARATOR "#"
-#define SUBSESSION_HISTOGRAM_PREFIX "sub#"
+const char KEYED_HISTOGRAM_NAME_SEPARATOR[] = "#";
+#if !defined(MOZ_WIDGET_GONK) && !defined(MOZ_WIDGET_ANDROID)
+const char SUBSESSION_HISTOGRAM_PREFIX[] = "sub#";
+#endif
 
 enum reflectStatus {
   REFLECT_OK,
   REFLECT_CORRUPT,
   REFLECT_FAILURE
 };
 
 nsresult
@@ -864,17 +866,17 @@ IsExpired(const char *expiration){
 bool
 IsExpired(const Histogram *histogram){
   return histogram->histogram_name() == EXPIRED_ID;
 }
 
 bool
 IsValidHistogramName(const nsACString& name)
 {
-  return !FindInReadable(NS_LITERAL_CSTRING(KEYED_HISTOGRAM_NAME_SEPARATOR), name);
+  return !FindInReadable(nsCString(KEYED_HISTOGRAM_NAME_SEPARATOR), name);
 }
 
 bool
 IsInDataset(uint32_t dataset, uint32_t containingDataset)
 {
   if (dataset == containingDataset) {
     return true;
   }
@@ -4141,21 +4143,21 @@ KeyedHistogram::GetHistogram(const nsCSt
   if (entry) {
     *histogram = entry->mData;
     return NS_OK;
   }
 
   nsCString histogramName;
 #if !defined(MOZ_WIDGET_GONK) && !defined(MOZ_WIDGET_ANDROID)
   if (subsession) {
-    histogramName.AppendLiteral(SUBSESSION_HISTOGRAM_PREFIX);
+    histogramName.Append(SUBSESSION_HISTOGRAM_PREFIX);
   }
 #endif
   histogramName.Append(mName);
-  histogramName.AppendLiteral(KEYED_HISTOGRAM_NAME_SEPARATOR);
+  histogramName.Append(KEYED_HISTOGRAM_NAME_SEPARATOR);
   histogramName.Append(key);
 
   Histogram* h;
   nsresult rv = HistogramGet(histogramName.get(), mExpiration.get(),
                              mHistogramType, mMin, mMax, mBucketCount,
                              true, &h);
   if (NS_FAILED(rv)) {
     return rv;
--- a/toolkit/xre/nsUpdateDriver.cpp
+++ b/toolkit/xre/nsUpdateDriver.cpp
@@ -77,26 +77,26 @@ GetUpdateLog()
   static PRLogModuleInfo *sUpdateLog;
   if (!sUpdateLog)
     sUpdateLog = PR_NewLogModule("updatedriver");
   return sUpdateLog;
 }
 #define LOG(args) PR_LOG(GetUpdateLog(), PR_LOG_DEBUG, args)
 
 #ifdef XP_WIN
-#define UPDATER_BIN "updater.exe"
+static const char kUpdaterBin[] = "updater.exe";
 #else
-#define UPDATER_BIN "updater"
+static const char kUpdaterBin[] = "updater";
 #endif
-#define UPDATER_INI "updater.ini"
+static const char kUpdaterINI[] = "updater.ini";
 #ifdef XP_MACOSX
-#define UPDATER_APP "updater.app"
+static const char kUpdaterApp[] = "updater.app";
 #endif
 #if defined(XP_UNIX) && !defined(XP_MACOSX)
-#define UPDATER_PNG "updater.png"
+static const char kUpdaterPNG[] = "updater.png";
 #endif
 
 #if defined(MOZ_WIDGET_GONK)
 #include <linux/ioprio.h>
 
 static const int kB2GServiceArgc = 2;
 static const char *kB2GServiceArgv[] = { "/system/bin/start", "b2g" };
 
@@ -325,18 +325,19 @@ IsOlderVersion(nsIFile *versionFile, con
 
   if (mozilla::Version(appVersion) > buf)
     return true;
 
   return false;
 }
 
 static bool
-CopyFileIntoUpdateDir(nsIFile *parentDir, const nsACString& leaf, nsIFile *updateDir)
+CopyFileIntoUpdateDir(nsIFile *parentDir, const char *leafName, nsIFile *updateDir)
 {
+  nsDependentCString leaf(leafName);
   nsCOMPtr<nsIFile> file;
 
   // Make sure there is not an existing file in the target location.
   nsresult rv = updateDir->Clone(getter_AddRefs(file));
   if (NS_FAILED(rv))
     return false;
   rv = file->AppendNative(leaf);
   if (NS_FAILED(rv))
@@ -358,46 +359,46 @@ CopyFileIntoUpdateDir(nsIFile *parentDir
 }
 
 static bool
 CopyUpdaterIntoUpdateDir(nsIFile *greDir, nsIFile *appDir, nsIFile *updateDir,
                          nsCOMPtr<nsIFile> &updater)
 {
   // Copy the updater application from the GRE and the updater ini from the app
 #if defined(XP_MACOSX)
-  if (!CopyFileIntoUpdateDir(appDir, NS_LITERAL_CSTRING(UPDATER_APP), updateDir))
+  if (!CopyFileIntoUpdateDir(appDir, kUpdaterApp, updateDir))
     return false;
-  CopyFileIntoUpdateDir(greDir, NS_LITERAL_CSTRING(UPDATER_INI), updateDir);
+  CopyFileIntoUpdateDir(greDir, kUpdaterINI, updateDir);
 #else
-  if (!CopyFileIntoUpdateDir(greDir, NS_LITERAL_CSTRING(UPDATER_BIN), updateDir))
+  if (!CopyFileIntoUpdateDir(greDir, kUpdaterBin, updateDir))
     return false;
-  CopyFileIntoUpdateDir(appDir, NS_LITERAL_CSTRING(UPDATER_INI), updateDir);
+  CopyFileIntoUpdateDir(appDir, kUpdaterINI, updateDir);
 #endif
 #if defined(XP_UNIX) && !defined(XP_MACOSX) && !defined(ANDROID)
   nsCOMPtr<nsIFile> iconDir;
   appDir->Clone(getter_AddRefs(iconDir));
   iconDir->AppendNative(NS_LITERAL_CSTRING("icons"));
-  if (!CopyFileIntoUpdateDir(iconDir, NS_LITERAL_CSTRING(UPDATER_PNG), updateDir))
+  if (!CopyFileIntoUpdateDir(iconDir, kUpdaterPNG, updateDir))
     return false;
 #endif
   // Finally, return the location of the updater binary.
   nsresult rv = updateDir->Clone(getter_AddRefs(updater));
   if (NS_FAILED(rv))
     return false;
 #if defined(XP_MACOSX)
-  rv  = updater->AppendNative(NS_LITERAL_CSTRING(UPDATER_APP));
+  rv  = updater->AppendNative(NS_LITERAL_CSTRING(kUpdaterApp));
   nsresult tmp = updater->AppendNative(NS_LITERAL_CSTRING("Contents"));
   if (NS_FAILED(tmp)) {
     rv = tmp;
   }
   tmp = updater->AppendNative(NS_LITERAL_CSTRING("MacOS"));
   if (NS_FAILED(tmp) || NS_FAILED(rv))
     return false;
 #endif
-  rv = updater->AppendNative(NS_LITERAL_CSTRING(UPDATER_BIN));
+  rv = updater->AppendNative(NS_LITERAL_CSTRING(kUpdaterBin));
   return NS_SUCCEEDED(rv); 
 }
 
 /**
  * Appends the specified path to the library path.
  * This is used so that updater can find libmozsqlite3.so and other shared libs.
  *
  * @param pathToAppend A new library path to prepend to LD_LIBRARY_PATH
@@ -495,17 +496,18 @@ SwitchToUpdatedApp(nsIFile *greDir, nsIF
   NS_ConvertUTF16toUTF8 appFilePath(appFilePathW);
 
   nsCOMPtr<nsIFile> updater;
   rv = greDir->Clone(getter_AddRefs(updater));
   if (NS_FAILED(rv)) {
     return;
   }
 
-  rv = updater->AppendNative(NS_LITERAL_CSTRING(UPDATER_BIN));
+  nsDependentCString leaf(kUpdaterBin);
+  rv = updater->AppendNative(leaf);
   if (NS_FAILED(rv)) {
     return;
   }
 
   nsAutoString updaterPathW;
   rv = updater->GetPath(updaterPathW);
   if (NS_FAILED(rv)) {
     return;
@@ -763,17 +765,18 @@ ApplyUpdate(nsIFile *greDir, nsIFile *up
   NS_ConvertUTF16toUTF8 appFilePath(appFilePathW);
 
   nsCOMPtr<nsIFile> updater;
   rv = greDir->Clone(getter_AddRefs(updater));
   if (NS_FAILED(rv)) {
     return;
   }
 
-  rv = updater->AppendNative(NS_LITERAL_CSTRING(UPDATER_BIN));
+  nsDependentCString leaf(kUpdaterBin);
+  rv = updater->AppendNative(leaf);
   if (NS_FAILED(rv)) {
     return;
   }
 
   nsAutoString updaterPathW;
   rv = updater->GetPath(updaterPathW);
   if (NS_FAILED(rv)) {
     return;
--- a/xpcom/io/nsIFile.idl
+++ b/xpcom/io/nsIFile.idl
@@ -37,17 +37,17 @@ interface nsISimpleEnumerator;
  * All methods with string parameters have two forms.  The preferred
  * form operates on UCS-2 encoded characters strings.  An alternate
  * form operates on characters strings encoded in the "native" charset.
  *
  * A string containing characters encoded in the native charset cannot
  * be safely passed to javascript via xpconnect.  Therefore, the "native
  * methods" are not scriptable.
  */
-[scriptable, main_process_scriptable_only, uuid(890b802d-3522-4887-a892-3dab31df30d9), builtinclass]
+[scriptable, main_process_scriptable_only, uuid(7441fb13-4d9f-42fd-836f-a165692938af), builtinclass]
 interface nsIFile : nsISupports
 {
     /**
      *  Create Types
      *
      *  NORMAL_FILE_TYPE - A normal file.
      *  DIRECTORY_TYPE   - A directory/folder.
      */
@@ -184,17 +184,16 @@ interface nsIFile : nsISupports
      *  renameTo
      *
      *  This method is identical to moveTo except that if this file or directory
      *  is moved to a a different volume, it fails and returns an error
      *  (NS_ERROR_FILE_ACCESS_DENIED).
      *  This object will still point to the old location after renaming.
      */
     void renameTo(in nsIFile newParentDir, in AString newName);
-    [noscript] void renameToNative(in nsIFile newParentDir, in ACString newName);
 
     /**
      *  This will try to delete this file.  The 'recursive' flag
      *  must be PR_TRUE to delete directories which are not empty.
      *
      *  This will not resolve any symlinks.
      */
     void remove(in boolean recursive);
--- a/xpcom/io/nsLocalFileUnix.cpp
+++ b/xpcom/io/nsLocalFileUnix.cpp
@@ -2149,30 +2149,29 @@ nsresult
 nsLocalFile::MoveTo(nsIFile* aNewParentDir, const nsAString& aNewName)
 {
   SET_UCS_2ARGS_2(MoveToNative, aNewParentDir, aNewName);
 }
 
 NS_IMETHODIMP
 nsLocalFile::RenameTo(nsIFile* aNewParentDir, const nsAString& aNewName)
 {
-  SET_UCS_2ARGS_2(RenameToNative, aNewParentDir, aNewName);
-}
-
-NS_IMETHODIMP
-nsLocalFile::RenameToNative(nsIFile* aNewParentDir, const nsACString& aNewName)
-{
   nsresult rv;
 
   // check to make sure that this has been initialized properly
   CHECK_mPath();
 
   // check to make sure that we have a new parent
   nsAutoCString newPathName;
-  rv = GetNativeTargetPathName(aNewParentDir, aNewName, newPathName);
+  nsAutoCString newNativeName;
+  rv = NS_CopyUnicodeToNative(aNewName, newNativeName);
+  if (NS_FAILED(rv)) {
+    return rv;
+  }
+  rv = GetNativeTargetPathName(aNewParentDir, newNativeName, newPathName);
   if (NS_FAILED(rv)) {
     return rv;
   }
 
   // try for atomic rename
   if (rename(mPath.get(), newPathName.get()) < 0) {
 #ifdef VMS
     if (errno == EXDEV || errno == ENXIO) {
--- a/xpcom/io/nsLocalFileWin.cpp
+++ b/xpcom/io/nsLocalFileWin.cpp
@@ -2264,28 +2264,16 @@ nsLocalFile::RenameTo(nsIFile* aNewParen
   if (!aNewParentDir) {
     options |= SkipNtfsAclReset;
   }
   // Move single file, or move a directory
   return CopySingleFile(this, targetParentDir, aNewName, options);
 }
 
 NS_IMETHODIMP
-nsLocalFile::RenameToNative(nsIFile* aNewParentDir, const nsACString& aNewName)
-{
-  nsAutoString tmp;
-  nsresult rv = NS_CopyNativeToUnicode(aNewName, tmp);
-  if (NS_SUCCEEDED(rv)) {
-    return RenameTo(aNewParentDir, tmp);
-  }
-
-  return rv;
-}
-
-NS_IMETHODIMP
 nsLocalFile::Load(PRLibrary** aResult)
 {
   // Check we are correctly initialized.
   CHECK_mWorkingPath();
 
   bool isFile;
   nsresult rv = IsFile(&isFile);
 
--- a/xpcom/string/nsLiteralString.h
+++ b/xpcom/string/nsLiteralString.h
@@ -25,13 +25,13 @@
 #define NS_MULTILINE_LITERAL_STRING(s)            static_cast<const nsLiteralString&>(nsLiteralString(s))
 #define NS_MULTILINE_LITERAL_STRING_INIT(n,s)     n(s)
 #define NS_NAMED_MULTILINE_LITERAL_STRING(n,s)    const nsLiteralString n(s)
 
 #define NS_LITERAL_STRING(s)                      static_cast<const nsLiteralString&>(nsLiteralString(MOZ_UTF16(s)))
 #define NS_LITERAL_STRING_INIT(n,s)               n(MOZ_UTF16(s))
 #define NS_NAMED_LITERAL_STRING(n,s)              const nsLiteralString n(MOZ_UTF16(s))
 
-#define NS_LITERAL_CSTRING(s)                     static_cast<const nsLiteralCString&>(nsLiteralCString("" s))
-#define NS_LITERAL_CSTRING_INIT(n,s)              n("" s)
-#define NS_NAMED_LITERAL_CSTRING(n,s)             const nsLiteralCString n("" s)
+#define NS_LITERAL_CSTRING(s)                     static_cast<const nsLiteralCString&>(nsLiteralCString(s))
+#define NS_LITERAL_CSTRING_INIT(n,s)              n(s)
+#define NS_NAMED_LITERAL_CSTRING(n,s)             const nsLiteralCString n(s)
 
 #endif /* !defined(nsLiteralString_h___) */
--- a/xpfe/components/windowds/nsWindowDataSource.cpp
+++ b/xpfe/components/windowds/nsWindowDataSource.cpp
@@ -24,32 +24,33 @@ uint32_t nsWindowDataSource::windowCount
 nsIRDFResource* nsWindowDataSource::kNC_Name = nullptr;
 nsIRDFResource* nsWindowDataSource::kNC_WindowRoot = nullptr;
 nsIRDFResource* nsWindowDataSource::kNC_KeyIndex = nullptr;
 
 nsIRDFService*  nsWindowDataSource::gRDFService = nullptr;
 
 uint32_t nsWindowDataSource::gRefCnt = 0;
 
-#define URINC_WINDOWROOT "NC:WindowMediatorRoot"
-#define URINC_NAME       NC_NAMESPACE_URI "Name"
-#define URINC_KEYINDEX   NC_NAMESPACE_URI "KeyIndex"
+static const char kURINC_WindowRoot[] = "NC:WindowMediatorRoot";
+
+DEFINE_RDF_VOCAB(NC_NAMESPACE_URI, NC, Name);
+DEFINE_RDF_VOCAB(NC_NAMESPACE_URI, NC, KeyIndex);
 
 nsresult
 nsWindowDataSource::Init()
 {
     nsresult rv;
 
     if (gRefCnt++ == 0) {
         rv = CallGetService("@mozilla.org/rdf/rdf-service;1", &gRDFService);
         if (NS_FAILED(rv)) return rv;
 
-        gRDFService->GetResource(NS_LITERAL_CSTRING(URINC_WINDOWROOT), &kNC_WindowRoot);
-        gRDFService->GetResource(NS_LITERAL_CSTRING(URINC_NAME),       &kNC_Name);
-        gRDFService->GetResource(NS_LITERAL_CSTRING(URINC_KEYINDEX),   &kNC_KeyIndex);
+        gRDFService->GetResource(NS_LITERAL_CSTRING(kURINC_WindowRoot), &kNC_WindowRoot);
+        gRDFService->GetResource(NS_LITERAL_CSTRING(kURINC_Name),       &kNC_Name);
+        gRDFService->GetResource(NS_LITERAL_CSTRING(kURINC_KeyIndex),   &kNC_KeyIndex);
     }
 
     mInner = do_CreateInstance("@mozilla.org/rdf/datasource;1?name=in-memory-datasource", &rv);
     if (NS_FAILED(rv)) return rv;
 
     nsCOMPtr<nsIRDFContainerUtils> rdfc =
         do_GetService("@mozilla.org/rdf/container-utils;1", &rv);
     if (NS_FAILED(rv)) return rv;