--- 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;