Rename LOG() to LOG_INFO()

Source/WebCore/Modules/webdatabase/SQLTransactionBackend.cpp

 /*
  * Copyright (C) 2007, 2008, 2013 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
@@ skipping 473 matching lines @@
     // cleaning up and shutting down:
     if (m_database->opened() && !m_database->isInterrupted()) {
         setStateToRequestedState();
         ASSERT(m_nextState == SQLTransactionState::AcquireLock
             || m_nextState == SQLTransactionState::OpenTransactionAndPreflight
             || m_nextState == SQLTransactionState::RunStatements
             || m_nextState == SQLTransactionState::PostflightAndCommit
             || m_nextState == SQLTransactionState::CleanupAndTerminate
             || m_nextState == SQLTransactionState::CleanupAfterTransactionErrorCallback);
 
-        LOG(StorageAPI, "State %s\n", nameForSQLTransactionState(m_nextState));
+        LOG_INFO(StorageAPI, "State %s\n", nameForSQLTransactionState(m_nextState));
         return;
     }
 
     // If we get here, then we should be shutting down. Do clean up if needed:
     if (m_nextState == SQLTransactionState::End)
         return;
     m_nextState = SQLTransactionState::End;
 
     // If the database was stopped, don't do anything and cancel queued work
-    LOG(StorageAPI, "Database was stopped or interrupted - cancelling work for this transaction");
+    LOG_INFO(StorageAPI, "Database was stopped or interrupted - cancelling work for this transaction");
 
     // The current SQLite transaction should be stopped, as well
     if (m_sqliteTransaction) {
         m_sqliteTransaction->stop();
         m_sqliteTransaction.clear();
     }
 
     // Terminate the frontend state machine. This also gets the frontend to
     // call computeNextStateAndCleanupIfNeeded() and clear its wrappers
     // if needed.
@@ skipping 43 matching lines @@
 {
     m_lockAcquired = true;
     requestTransitToState(SQLTransactionState::OpenTransactionAndPreflight);
 }
 
 SQLTransactionState SQLTransactionBackend::openTransactionAndPreflight()
 {
     ASSERT(!m_database->sqliteDatabase().transactionInProgress());
     ASSERT(m_lockAcquired);
 
-    LOG(StorageAPI, "Opening and preflighting transaction %p", this);
+    LOG_INFO(StorageAPI, "Opening and preflighting transaction %p", this);
 
     // If the database was deleted, jump to the error callback
     if (Database::from(m_database.get())->deleted()) {
         m_database->reportStartTransactionResult(1, SQLError::UNKNOWN_ERR, 0);
         m_transactionError = SQLError::create(SQLError::UNKNOWN_ERR, "unable to open a transaction, because the user deleted the database");
         return nextStateForTransactionError();
     }
 
     // Set the maximum usage for this transaction if this transactions is not read-only
     if (!m_readOnly) {
@@ skipping 192 matching lines @@
 
     // Spec 4.3.2.8: Deliver success callback, if there is one.
     return SQLTransactionState::DeliverSuccessCallback;
 }
 
 SQLTransactionState SQLTransactionBackend::cleanupAndTerminate()
 {
     ASSERT(m_lockAcquired);
 
     // Spec 4.3.2.9: End transaction steps. There is no next step.
-    LOG(StorageAPI, "Transaction %p is complete\n", this);
+    LOG_INFO(StorageAPI, "Transaction %p is complete\n", this);
     ASSERT(!m_database->sqliteDatabase().transactionInProgress());
 
     // Phase 5 cleanup. See comment on the SQLTransaction life-cycle above.
     doCleanup();
     m_database->inProgressTransactionCompleted();
     return SQLTransactionState::End;
 }
 
 SQLTransactionState SQLTransactionBackend::nextStateForTransactionError()
 {
     ASSERT(m_transactionError);
     if (m_hasErrorCallback)
         return SQLTransactionState::DeliverTransactionErrorCallback;
 
     // No error callback, so fast-forward to the next state and rollback the
     // transaction.
     return SQLTransactionState::CleanupAfterTransactionErrorCallback;
 }
 
 SQLTransactionState SQLTransactionBackend::cleanupAfterTransactionErrorCallback()
 {
     ASSERT(m_lockAcquired);
 
-    LOG(StorageAPI, "Transaction %p is complete with an error\n", this);
+    LOG_INFO(StorageAPI, "Transaction %p is complete with an error\n", this);
     m_database->disableAuthorizer();
     if (m_sqliteTransaction) {
         // Spec 4.3.2.10: Rollback the transaction.
         m_sqliteTransaction->rollback();
 
         ASSERT(!m_database->sqliteDatabase().transactionInProgress());
         m_sqliteTransaction.clear();
     }
     m_database->enableAuthorizer();
 
     releaseOriginLockIfNeeded();
 
     ASSERT(!m_database->sqliteDatabase().transactionInProgress());
 
     return SQLTransactionState::CleanupAndTerminate;
 }
 
 // requestTransitToState() can be called from the frontend. Hence, it should
 // NOT be modifying SQLTransactionBackend in general. The only safe field to
 // modify is m_requestedState which is meant for this purpose.
 void SQLTransactionBackend::requestTransitToState(SQLTransactionState nextState)
 {
-    LOG(StorageAPI, "Scheduling %s for transaction %p\n", nameForSQLTransactionState(nextState), this);
+    LOG_INFO(StorageAPI, "Scheduling %s for transaction %p\n", nameForSQLTransactionState(nextState), this);
     m_requestedState = nextState;
     ASSERT(m_requestedState != SQLTransactionState::End);
     m_database->scheduleTransactionStep(this);
 }
 
 // This state function is used as a stub function to plug unimplemented states
 // in the state dispatch table. They are unimplemented because they should
 // never be reached in the course of correct execution.
 SQLTransactionState SQLTransactionBackend::unreachableState()
 {
@@ skipping 23 matching lines @@
     if (m_originLock) {
         m_originLock->unlock();
         m_originLock.clear();
     }
 #endif
 }
 
 } // namespace WebCore
 
 #endif // ENABLE(SQL_DATABASE)