Web SQL: Replace WTF_LOG() with STORAGE_DVLOG() or SQL_DVLOG().

third_party/WebKit/Source/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 20 matching lines @@
 #include "modules/webdatabase/Database.h"
 #include "modules/webdatabase/DatabaseAuthorizer.h"
 #include "modules/webdatabase/DatabaseContext.h"
 #include "modules/webdatabase/DatabaseThread.h"
 #include "modules/webdatabase/DatabaseTracker.h"
 #include "modules/webdatabase/SQLError.h"
 #include "modules/webdatabase/SQLStatementBackend.h"
 #include "modules/webdatabase/SQLTransaction.h"
 #include "modules/webdatabase/SQLTransactionClient.h"
 #include "modules/webdatabase/SQLTransactionCoordinator.h"
+#include "modules/webdatabase/StorageLog.h"
 #include "modules/webdatabase/sqlite/SQLValue.h"
 #include "modules/webdatabase/sqlite/SQLiteTransaction.h"
-#include "platform/Logging.h"
 #include "wtf/PtrUtil.h"
 #include "wtf/StdLibExtras.h"
 #include <memory>
 
 
 // How does a SQLTransaction work?
 // ==============================
 // The SQLTransaction is a state machine that executes a series of states / steps.
 //
 // The work of the transaction states are defined in section of 4.3.2 of the
@@ skipping 424 matching lines @@
     // Only honor the requested state transition if we're not supposed to be
     // cleaning up and shutting down:
     if (m_database->opened()) {
         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);
-
-        WTF_LOG(StorageAPI, "State %s\n", nameForSQLTransactionState(m_nextState));
+#if DCHECK_IS_ON()
+        STORAGE_DVLOG(1) << "State " << nameForSQLTransactionState(m_nextState);
+#endif
         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
-    WTF_LOG(StorageAPI, "Database was stopped or interrupted - cancelling work for this transaction");
+    STORAGE_DVLOG(1) << "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.reset();
     }
 
     // Terminate the frontend state machine. This also gets the frontend to
     // call computeNextStateAndCleanupIfNeeded() and clear its wrappers
     // if needed.
@@ skipping 39 matching lines @@
     m_lockAcquired = true;
     requestTransitToState(SQLTransactionState::OpenTransactionAndPreflight);
 }
 
 SQLTransactionState SQLTransactionBackend::openTransactionAndPreflight()
 {
     DCHECK(database()->getDatabaseContext()->databaseThread()->isDatabaseThread());
     ASSERT(!m_database->sqliteDatabase().transactionInProgress());
     ASSERT(m_lockAcquired);
 
-    WTF_LOG(StorageAPI, "Opening and preflighting transaction %p", this);
+    STORAGE_DVLOG(1) << "Opening and preflighting transaction " << this;
 
     // Set the maximum usage for this transaction if this transactions is not read-only
     if (!m_readOnly)
         m_database->sqliteDatabase().setMaximumSize(m_database->maximumSize());
 
     ASSERT(!m_sqliteTransaction);
     m_sqliteTransaction = wrapUnique(new SQLiteTransaction(m_database->sqliteDatabase(), m_readOnly));
 
     m_database->resetDeletes();
     m_database->disableAuthorizer();
@@ skipping 186 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.
-    WTF_LOG(StorageAPI, "Transaction %p is complete\n", this);
+    STORAGE_DVLOG(1) << "Transaction " << this << " is complete";
     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);
 
-    WTF_LOG(StorageAPI, "Transaction %p is complete with an error\n", this);
+    STORAGE_DVLOG(1) << "Transaction " << this << " is complete with an error";
     m_database->disableAuthorizer();
     if (m_sqliteTransaction) {
         // Spec 4.3.2.10: Rollback the transaction.
         m_sqliteTransaction->rollback();
 
         ASSERT(!m_database->sqliteDatabase().transactionInProgress());
         m_sqliteTransaction.reset();
     }
     m_database->enableAuthorizer();
 
     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)
 {
-    WTF_LOG(StorageAPI, "Scheduling %s for transaction %p\n", nameForSQLTransactionState(nextState), this);
+#if DCHECK_IS_ON()
+    STORAGE_DVLOG(1) << "Scheduling " << nameForSQLTransactionState(nextState) << " for transaction " << this;
+#endif
     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()
 {
     ASSERT_NOT_REACHED();
     return SQLTransactionState::End;
 }
 
 SQLTransactionState SQLTransactionBackend::sendToFrontendState()
 {
     ASSERT(m_nextState != SQLTransactionState::Idle);
     m_frontend->requestTransitToState(m_nextState);
     return SQLTransactionState::Idle;
 }
 
 } // namespace blink