Remove all uses of the ASCIILiteral class.

Source/core/platform/sql/SQLiteDatabase.cpp

 /*
  * Copyright (C) 2006, 2007, 2008 Apple Inc. All rights reserved.
  * Copyright (C) 2007 Justin Haygood (jhaygood@reaktix.com)
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
@@ skipping 77 matching lines @@
         sqlite3_close(m_db);
         m_db = 0;
         return false;
     }
 
     if (isOpen())
         m_openingThread = currentThread();
     else
         m_openErrorMessage = "sqlite_open returned null";
 
-    if (!SQLiteStatement(*this, ASCIILiteral("PRAGMA temp_store = MEMORY;")).executeCommand())
+    if (!SQLiteStatement(*this, "PRAGMA temp_store = MEMORY;").executeCommand())
         LOG_ERROR("SQLite database could not set temp_store to memory");
 
     return isOpen();
 }
 
 void SQLiteDatabase::close()
 {
     if (m_db) {
         // FIXME: This is being called on the main thread during JS GC. <rdar://problem/5739818>
         // ASSERT(currentThread() == m_openingThread);
@@ skipping 26 matching lines @@
 
 bool SQLiteDatabase::isInterrupted()
 {
     ASSERT(!m_lockingMutex.tryLock());
     return m_interrupted;
 }
 
 void SQLiteDatabase::setFullsync(bool fsync)
 {
     if (fsync)
-        executeCommand(ASCIILiteral("PRAGMA fullfsync = 1;"));
+        executeCommand("PRAGMA fullfsync = 1;");
     else
-        executeCommand(ASCIILiteral("PRAGMA fullfsync = 0;"));
+        executeCommand("PRAGMA fullfsync = 0;");
 }
 
 int64_t SQLiteDatabase::maximumSize()
 {
     int64_t maxPageCount = 0;
 
     {
         MutexLocker locker(m_authorizerLock);
         enableAuthorizer(false);
-        SQLiteStatement statement(*this, ASCIILiteral("PRAGMA max_page_count"));
+        SQLiteStatement statement(*this, "PRAGMA max_page_count");
         maxPageCount = statement.getColumnInt64(0);
         enableAuthorizer(true);
     }
 
     return maxPageCount * pageSize();
 }
 
 void SQLiteDatabase::setMaximumSize(int64_t size)
 {
     if (size < 0)
@@ skipping 21 matching lines @@
 }
 
 int SQLiteDatabase::pageSize()
 {
     // Since the page size of a database is locked in at creation and therefore cannot be dynamic,
     // we can cache the value for future use
     if (m_pageSize == -1) {
         MutexLocker locker(m_authorizerLock);
         enableAuthorizer(false);
 
-        SQLiteStatement statement(*this, ASCIILiteral("PRAGMA page_size"));
+        SQLiteStatement statement(*this, "PRAGMA page_size");
         m_pageSize = statement.getColumnInt(0);
 
         enableAuthorizer(true);
     }
 
     return m_pageSize;
 }
 
 int64_t SQLiteDatabase::freeSpaceSize()
 {
     int64_t freelistCount = 0;
 
     {
         MutexLocker locker(m_authorizerLock);
         enableAuthorizer(false);
         // Note: freelist_count was added in SQLite 3.4.1.
-        SQLiteStatement statement(*this, ASCIILiteral("PRAGMA freelist_count"));
+        SQLiteStatement statement(*this, "PRAGMA freelist_count");
         freelistCount = statement.getColumnInt64(0);
         enableAuthorizer(true);
     }
 
     return freelistCount * pageSize();
 }
 
 int64_t SQLiteDatabase::totalSize()
 {
     int64_t pageCount = 0;
 
     {
         MutexLocker locker(m_authorizerLock);
         enableAuthorizer(false);
-        SQLiteStatement statement(*this, ASCIILiteral("PRAGMA page_count"));
+        SQLiteStatement statement(*this, "PRAGMA page_count");
         pageCount = statement.getColumnInt64(0);
         enableAuthorizer(true);
     }
 
     return pageCount * pageSize();
 }
 
 void SQLiteDatabase::setSynchronous(SynchronousPragma sync)
 {
     executeCommand("PRAGMA synchronous = " + String::number(sync));
@@ skipping 32 matching lines @@
 
     String statement = "SELECT name FROM sqlite_master WHERE type = 'table' AND name = '" + tablename + "';";
 
     SQLiteStatement sql(*this, statement);
     sql.prepare();
     return sql.step() == SQLITE_ROW;
 }
 
 void SQLiteDatabase::clearAllTables()
 {
-    String query = ASCIILiteral("SELECT name FROM sqlite_master WHERE type='table';");
+    String query = "SELECT name FROM sqlite_master WHERE type='table';";
     Vector<String> tables;
     if (!SQLiteStatement(*this, query).returnTextResults(0, tables)) {
         LOG(SQLDatabase, "Unable to retrieve list of tables from database");
         return;
     }
 
     for (Vector<String>::iterator table = tables.begin(); table != tables.end(); ++table ) {
         if (*table == "sqlite_sequence")
             continue;
         if (!executeCommand("DROP TABLE " + *table))
             LOG(SQLDatabase, "Unable to drop table %s", (*table).ascii().data());
     }
 }
 
 int SQLiteDatabase::runVacuumCommand()
 {
-    if (!executeCommand(ASCIILiteral("VACUUM;")))
+    if (!executeCommand("VACUUM;"))
         LOG(SQLDatabase, "Unable to vacuum database - %s", lastErrorMsg());
     return lastError();
 }
 
 int SQLiteDatabase::runIncrementalVacuumCommand()
 {
     MutexLocker locker(m_authorizerLock);
     enableAuthorizer(false);
 
-    if (!executeCommand(ASCIILiteral("PRAGMA incremental_vacuum")))
+    if (!executeCommand("PRAGMA incremental_vacuum"))
         LOG(SQLDatabase, "Unable to run incremental vacuum - %s", lastErrorMsg());
 
     enableAuthorizer(true);
     return lastError();
 }
 
 int64_t SQLiteDatabase::lastInsertRowID()
 {
     if (!m_db)
         return 0;
@@ skipping 139 matching lines @@
         sqlite3_set_authorizer(m_db, NULL, 0);
 }
 
 bool SQLiteDatabase::isAutoCommitOn() const
 {
     return sqlite3_get_autocommit(m_db);
 }
 
 bool SQLiteDatabase::turnOnIncrementalAutoVacuum()
 {
-    SQLiteStatement statement(*this, ASCIILiteral("PRAGMA auto_vacuum"));
+    SQLiteStatement statement(*this, "PRAGMA auto_vacuum");
     int autoVacuumMode = statement.getColumnInt(0);
     int error = lastError();
 
     // Check if we got an error while trying to get the value of the auto_vacuum flag.
     // If we got a SQLITE_BUSY error, then there's probably another transaction in
     // progress on this database. In this case, keep the current value of the
     // auto_vacuum flag and try to set it to INCREMENTAL the next time we open this
     // database. If the error is not SQLITE_BUSY, then we probably ran into a more
     // serious problem and should return false (to log an error message).
     if (error != SQLITE_ROW)
         return false;
 
     switch (autoVacuumMode) {
     case AutoVacuumIncremental:
         return true;
     case AutoVacuumFull:
-        return executeCommand(ASCIILiteral("PRAGMA auto_vacuum = 2"));
+        return executeCommand("PRAGMA auto_vacuum = 2");
     case AutoVacuumNone:
     default:
-        if (!executeCommand(ASCIILiteral("PRAGMA auto_vacuum = 2")))
+        if (!executeCommand("PRAGMA auto_vacuum = 2"))
             return false;
         runVacuumCommand();
         error = lastError();
         return (error == SQLITE_OK);
     }
 }
 
 } // namespace WebCore