Rename LOG() to LOG_INFO()

Source/WebCore/platform/sql/SQLiteStatement.cpp

 /*
  * Copyright (C) 2006, 2007, 2008 Apple Inc. All rights reserved.
  *
  * 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
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 50 matching lines @@
 
 int SQLiteStatement::prepare()
 {
     ASSERT(!m_isPrepared);
 
     MutexLocker databaseLock(m_database.databaseMutex());
     if (m_database.isInterrupted())
         return SQLITE_INTERRUPT;
 
     const void* tail = 0;
-    LOG(SQLDatabase, "SQL - prepare - %s", m_query.ascii().data());
+    LOG_INFO(SQLDatabase, "SQL - prepare - %s", m_query.ascii().data());
     String strippedQuery = m_query.stripWhiteSpace();
     const UChar* nullTermed = strippedQuery.charactersWithNullTermination();
     int error = sqlite3_prepare16_v2(m_database.sqlite3Handle(), nullTermed, -1, &m_statement, &tail);
 
     // Starting with version 3.6.16, sqlite has a patch (http://www.sqlite.org/src/ci/256ec3c6af)
     // that should make sure sqlite3_prepare16_v2 doesn't return a SQLITE_SCHEMA error.
     // If we're using an older sqlite version, try to emulate the patch.
     if (error == SQLITE_SCHEMA) {
       sqlite3_finalize(m_statement);
       error = sqlite3_prepare16_v2(m_database.sqlite3Handle(), m_query.charactersWithNullTermination(), -1, &m_statement, &tail);
     }
 
     if (error != SQLITE_OK)
-        LOG(SQLDatabase, "sqlite3_prepare16 failed (%i)\n%s\n%s", error, m_query.ascii().data(), sqlite3_errmsg(m_database.sqlite3Handle()));
+        LOG_INFO(SQLDatabase, "sqlite3_prepare16 failed (%i)\n%s\n%s", error, m_query.ascii().data(), sqlite3_errmsg(m_database.sqlite3Handle()));
     const UChar* ch = static_cast<const UChar*>(tail);
     if (ch && *ch)
         error = SQLITE_ERROR;
 #ifndef NDEBUG
     m_isPrepared = error == SQLITE_OK;
 #endif
     return error;
 }
 
 int SQLiteStatement::step()
 {
     MutexLocker databaseLock(m_database.databaseMutex());
     if (m_database.isInterrupted())
         return SQLITE_INTERRUPT;
     //ASSERT(m_isPrepared);
 
     if (!m_statement)
         return SQLITE_OK;
 
     // The database needs to update its last changes count before each statement
     // in order to compute properly the lastChanges() return value.
     m_database.updateLastChangesCount();
 
-    LOG(SQLDatabase, "SQL - step - %s", m_query.ascii().data());
+    LOG_INFO(SQLDatabase, "SQL - step - %s", m_query.ascii().data());
     int error = sqlite3_step(m_statement);
     if (error != SQLITE_DONE && error != SQLITE_ROW) {
-        LOG(SQLDatabase, "sqlite3_step failed (%i)\nQuery - %s\nError - %s", 
-            error, m_query.ascii().data(), sqlite3_errmsg(m_database.sqlite3Handle()));
+        LOG_INFO(SQLDatabase, "sqlite3_step failed (%i)\nQuery - %s\nError - %s",
+                 error, m_query.ascii().data(), sqlite3_errmsg(m_database.sqlite3Handle()));
     }
 
     return error;
 }
     
 int SQLiteStatement::finalize()
 {
 #ifndef NDEBUG
     m_isPrepared = false;
 #endif
     if (!m_statement)
         return SQLITE_OK;
-    LOG(SQLDatabase, "SQL - finalize - %s", m_query.ascii().data());
+    LOG_INFO(SQLDatabase, "SQL - finalize - %s", m_query.ascii().data());
     int result = sqlite3_finalize(m_statement);
     m_statement = 0;
     return result;
 }
 
 int SQLiteStatement::reset() 
 {
     ASSERT(m_isPrepared);
     if (!m_statement)
         return SQLITE_OK;
-    LOG(SQLDatabase, "SQL - reset - %s", m_query.ascii().data());
+    LOG_INFO(SQLDatabase, "SQL - reset - %s", m_query.ascii().data());
     return sqlite3_reset(m_statement);
 }
 
 bool SQLiteStatement::executeCommand()
 {
     if (!m_statement && prepare() != SQLITE_OK)
         return false;
     ASSERT(m_isPrepared);
     if (step() != SQLITE_DONE) {
         finalize();
@@ skipping 284 matching lines @@
         result[i] = (static_cast<const unsigned char*>(blob))[i];
 }
 
 const void* SQLiteStatement::getColumnBlob(int col, int& size)
 {
     ASSERT(col >= 0);
 
     size = 0;
 
     if (finalize() != SQLITE_OK)
-        LOG(SQLDatabase, "Finalize failed");
+        LOG_INFO(SQLDatabase, "Finalize failed");
     if (prepare() != SQLITE_OK) {
-        LOG(SQLDatabase, "Prepare failed");
+        LOG_INFO(SQLDatabase, "Prepare failed");
         return 0;
     }
     if (step() != SQLITE_ROW) {
-        LOG(SQLDatabase, "Step wasn't a row");
+        LOG_INFO(SQLDatabase, "Step wasn't a row");
         return 0;
     }
 
     if (columnCount() <= col)
         return 0;
         
     const void* blob = sqlite3_column_blob(m_statement, col);
     if (!blob)
         return 0;
 
@@ skipping 10 matching lines @@
     if (m_statement)
         finalize();
     if (prepare() != SQLITE_OK)
         return false;
 
     while (step() == SQLITE_ROW)
         v.append(getColumnText(col));
     bool result = true;
     if (m_database.lastError() != SQLITE_DONE) {
         result = false;
-        LOG(SQLDatabase, "Error reading results from database query %s", m_query.ascii().data());
+        LOG_INFO(SQLDatabase, "Error reading results from database query %s", m_query.ascii().data());
     }
     finalize();
     return result;
 }
 
 bool SQLiteStatement::returnIntResults(int col, Vector<int>& v)
 {
     v.clear();
 
     if (m_statement)
         finalize();
     if (prepare() != SQLITE_OK)
         return false;
         
     while (step() == SQLITE_ROW)
         v.append(getColumnInt(col));
     bool result = true;
     if (m_database.lastError() != SQLITE_DONE) {
         result = false;
-        LOG(SQLDatabase, "Error reading results from database query %s", m_query.ascii().data());
+        LOG_INFO(SQLDatabase, "Error reading results from database query %s", m_query.ascii().data());
     }
     finalize();
     return result;
 }
 
 bool SQLiteStatement::returnInt64Results(int col, Vector<int64_t>& v)
 {
     v.clear();
 
     if (m_statement)
         finalize();
     if (prepare() != SQLITE_OK)
         return false;
         
     while (step() == SQLITE_ROW)
         v.append(getColumnInt64(col));
     bool result = true;
     if (m_database.lastError() != SQLITE_DONE) {
         result = false;
-        LOG(SQLDatabase, "Error reading results from database query %s", m_query.ascii().data());
+        LOG_INFO(SQLDatabase, "Error reading results from database query %s", m_query.ascii().data());
     }
     finalize();
     return result;
 }
 
 bool SQLiteStatement::returnDoubleResults(int col, Vector<double>& v)
 {
     v.clear();
 
     if (m_statement)
         finalize();
     if (prepare() != SQLITE_OK)
         return false;
 
     while (step() == SQLITE_ROW)
         v.append(getColumnDouble(col));
     bool result = true;
     if (m_database.lastError() != SQLITE_DONE) {
         result = false;
-        LOG(SQLDatabase, "Error reading results from database query %s", m_query.ascii().data());
+        LOG_INFO(SQLDatabase, "Error reading results from database query %s", m_query.ascii().data());
     }
     finalize();
     return result;
 }
 
 bool SQLiteStatement::isExpired()
 {
     return !m_statement || sqlite3_expired(m_statement);
 }
 
 } // namespace WebCore