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

third_party/WebKit/Source/modules/webdatabase/Database.cpp

 /*
  * Copyright (C) 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
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 28 matching lines @@
 #include "modules/webdatabase/DatabaseTask.h"
 #include "modules/webdatabase/DatabaseThread.h"
 #include "modules/webdatabase/DatabaseTracker.h"
 #include "modules/webdatabase/SQLError.h"
 #include "modules/webdatabase/SQLTransaction.h"
 #include "modules/webdatabase/SQLTransactionBackend.h"
 #include "modules/webdatabase/SQLTransactionCallback.h"
 #include "modules/webdatabase/SQLTransactionClient.h"
 #include "modules/webdatabase/SQLTransactionCoordinator.h"
 #include "modules/webdatabase/SQLTransactionErrorCallback.h"
+#include "modules/webdatabase/StorageLog.h"
 #include "modules/webdatabase/sqlite/SQLiteStatement.h"
 #include "modules/webdatabase/sqlite/SQLiteTransaction.h"
-#include "platform/Logging.h"
 #include "platform/heap/SafePoint.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebDatabaseObserver.h"
 #include "public/platform/WebSecurityOrigin.h"
 #include "wtf/Atomics.h"
 #include "wtf/CurrentTime.h"
 #include <memory>
 
 // Registering "opened" databases with the DatabaseTracker
 // =======================================================
@@ skipping 264 matching lines @@
 void Database::scheduleTransaction()
 {
     ASSERT(!m_transactionInProgressMutex.tryLock()); // Locked by caller.
     SQLTransactionBackend* transaction = nullptr;
 
     if (m_isTransactionQueueEnabled && !m_transactionQueue.isEmpty())
         transaction = m_transactionQueue.takeFirst();
 
     if (transaction && getDatabaseContext()->databaseThreadAvailable()) {
         std::unique_ptr<DatabaseTransactionTask> task = DatabaseTransactionTask::create(transaction);
-        WTF_LOG(StorageAPI, "Scheduling DatabaseTransactionTask %p for transaction %p\n", task.get(), task->transaction());
+        STORAGE_DVLOG(1) << "Scheduling DatabaseTransactionTask " << task.get() << " for transaction " << task->transaction();
         m_transactionInProgress = true;
         getDatabaseContext()->databaseThread()->scheduleTask(std::move(task));
     } else {
         m_transactionInProgress = false;
     }
 }
 
 void Database::scheduleTransactionStep(SQLTransactionBackend* transaction)
 {
     if (!getDatabaseContext()->databaseThreadAvailable())
         return;
 
     std::unique_ptr<DatabaseTransactionTask> task = DatabaseTransactionTask::create(transaction);
-    WTF_LOG(StorageAPI, "Scheduling DatabaseTransactionTask %p for the transaction step\n", task.get());
+    STORAGE_DVLOG(1) << "Scheduling DatabaseTransactionTask " << task.get() << " for the transaction step";
     getDatabaseContext()->databaseThread()->scheduleTask(std::move(task));
 }
 
 SQLTransactionClient* Database::transactionClient() const
 {
     return getDatabaseContext()->databaseThread()->transactionClient();
 }
 
 SQLTransactionCoordinator* Database::transactionCoordinator() const
 {
@@ skipping 77 matching lines @@
     m_sqliteDatabase.setBusyTimeout(maxSqliteBusyWaitTime);
 
     String currentVersion;
     {
         SafePointAwareMutexLocker locker(guidMutex());
 
         GuidVersionMap::iterator entry = guidToVersionMap().find(m_guid);
         if (entry != guidToVersionMap().end()) {
             // Map null string to empty string (see updateGuidVersionMap()).
             currentVersion = entry->value.isNull() ? emptyString() : entry->value.isolatedCopy();
-            WTF_LOG(StorageAPI, "Current cached version for guid %i is %s", m_guid, currentVersion.ascii().data());
+            STORAGE_DVLOG(1) << "Current cached version for guid " << m_guid << " is " << currentVersion;
 
             // Note: In multi-process browsers the cached value may be
             // inaccurate, but we cannot read the actual version from the
             // database without potentially inducing a form of deadlock, a
             // busytimeout error when trying to access the database. So we'll
             // use the cached value if we're unable to read the value from the
             // database file without waiting.
             // FIXME: Add an async openDatabase method to the DatabaseAPI.
             const int noSqliteBusyWaitTime = 0;
             m_sqliteDatabase.setBusyTimeout(noSqliteBusyWaitTime);
             String versionFromDatabase;
             if (getVersionFromDatabase(versionFromDatabase, false)) {
                 currentVersion = versionFromDatabase;
                 updateGuidVersionMap(m_guid, currentVersion);
             }
             m_sqliteDatabase.setBusyTimeout(maxSqliteBusyWaitTime);
         } else {
-            WTF_LOG(StorageAPI, "No cached version for guid %i", m_guid);
+            STORAGE_DVLOG(1) << "No cached version for guid " << m_guid;
 
             SQLiteTransaction transaction(m_sqliteDatabase);
             transaction.begin();
             if (!transaction.inProgress()) {
                 reportOpenDatabaseResult(2, InvalidStateError, m_sqliteDatabase.lastError(), WTF::monotonicallyIncreasingTime() - callStartTime);
                 errorMessage = formatErrorMessage("unable to open database, failed to start transaction", m_sqliteDatabase.lastError(), m_sqliteDatabase.lastErrorMsg());
                 m_sqliteDatabase.close();
                 return false;
             }
 
@@ skipping 10 matching lines @@
                 }
             } else if (!getVersionFromDatabase(currentVersion, false)) {
                 reportOpenDatabaseResult(4, InvalidStateError, m_sqliteDatabase.lastError(), WTF::monotonicallyIncreasingTime() - callStartTime);
                 errorMessage = formatErrorMessage("unable to open database, failed to read current version", m_sqliteDatabase.lastError(), m_sqliteDatabase.lastErrorMsg());
                 transaction.rollback();
                 m_sqliteDatabase.close();
                 return false;
             }
 
             if (currentVersion.length()) {
-                WTF_LOG(StorageAPI, "Retrieved current version %s from database %s", currentVersion.ascii().data(), databaseDebugName().ascii().data());
+                STORAGE_DVLOG(1) << "Retrieved current version " << currentVersion << " from database " << databaseDebugName();
             } else if (!m_new || shouldSetVersionInNewDatabase) {
-                WTF_LOG(StorageAPI, "Setting version %s in database %s that was just created", m_expectedVersion.ascii().data(), databaseDebugName().ascii().data());
+                STORAGE_DVLOG(1) << "Setting version " << m_expectedVersion << " in database " << databaseDebugName() << " that was just created";
                 if (!setVersionInDatabase(m_expectedVersion, false)) {
                     reportOpenDatabaseResult(5, InvalidStateError, m_sqliteDatabase.lastError(), WTF::monotonicallyIncreasingTime() - callStartTime);
                     errorMessage = formatErrorMessage("unable to open database, failed to write current version", m_sqliteDatabase.lastError(), m_sqliteDatabase.lastErrorMsg());
                     transaction.rollback();
                     m_sqliteDatabase.close();
                     return false;
                 }
                 currentVersion = m_expectedVersion;
             }
             updateGuidVersionMap(m_guid, currentVersion);
             transaction.commit();
         }
     }
 
     if (currentVersion.isNull()) {
-        WTF_LOG(StorageAPI, "Database %s does not have its version set", databaseDebugName().ascii().data());
+        STORAGE_DVLOG(1) << "Database " << databaseDebugName() << " does not have its version set";
         currentVersion = "";
     }
 
     // If the expected version isn't the empty string, ensure that the current
     // database version we have matches that version. Otherwise, set an
     // exception.
     // If the expected version is the empty string, then we always return with
     // whatever version of the database we have.
     if ((!m_new || shouldSetVersionInNewDatabase) && m_expectedVersion.length() && m_expectedVersion != currentVersion) {
         reportOpenDatabaseResult(6, InvalidStateError, 0, WTF::monotonicallyIncreasingTime() - callStartTime);
@@ skipping 377 matching lines @@
         return m_databaseThreadSecurityOrigin.get();
     return 0;
 }
 
 bool Database::opened()
 {
     return static_cast<bool>(acquireLoad(&m_opened));
 }
 
 } // namespace blink