Rename LOG() to LOG_INFO()

Source/WebCore/loader/icon/IconDatabase.cpp

 /*
  * Copyright (C) 2006, 2007, 2008, 2009, 2011 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 163 matching lines @@
     ASSERT(!isOpen());
 }
 
 void IconDatabase::removeAllIcons()
 {
     ASSERT_NOT_SYNC_THREAD();
     
     if (!isOpen())
         return;
 
-    LOG(IconDatabase, "Requesting background thread to remove all icons");
+    LOG_INFO(IconDatabase, "Requesting background thread to remove all icons");
     
     // Clear the in-memory record of every IconRecord, anything waiting to be read from disk, and anything waiting to be written to disk
     {
         MutexLocker locker(m_urlAndIconLock);
         
         // Clear the IconRecords for every page URL - RefCounting will cause the IconRecords themselves to be deleted
         // We don't delete the actual PageRecords because we have the "retain icon for url" count to keep track of
         HashMap<String, PageURLRecord*>::iterator iter = m_pageURLToRecordMap.begin();
         HashMap<String, PageURLRecord*>::iterator end = m_pageURLToRecordMap.end();
         for (; iter != end; ++iter)
@@ skipping 251 matching lines @@
 
         // If we read the iconURLs yet, we want to avoid any pageURL->iconURL lookups and the pageURLsPendingDeletion is moot, 
         // so we bail here and skip those steps
         if (!m_iconURLImportComplete)
             return;
 
         MutexLocker locker(m_pendingSyncLock);
         // If this pageURL waiting to be sync'ed, update the sync record
         // This saves us in the case where a page was ready to be deleted from the database but was just retained - so theres no need to delete it!
         if (!m_privateBrowsingEnabled && m_pageURLsPendingSync.contains(pageURL)) {
-            LOG(IconDatabase, "Bringing %s back from the brink", pageURL.ascii().data());
+            LOG_INFO(IconDatabase, "Bringing %s back from the brink", pageURL.ascii().data());
             m_pageURLsPendingSync.set(pageURL, record->snapshot());
         }
     }
 }
 
 void IconDatabase::releaseIconForPageURL(const String& pageURL)
 {
     ASSERT_NOT_SYNC_THREAD();
         
     // Cannot do anything with pageURLOriginal that would end up storing it without deep copying first
@@ skipping 13 matching lines @@
 {
     // Check if this pageURL is actually retained
     if (!m_retainedPageURLs.contains(pageURLOriginal)) {
         LOG_ERROR("Attempting to release icon for URL %s which is not retained", urlForLogging(pageURLOriginal).ascii().data());
         return;
     }
     
     // Get its retain count - if it's retained, we'd better have a PageURLRecord for it
     PageURLRecord* pageRecord = m_pageURLToRecordMap.get(pageURLOriginal);
     ASSERT(pageRecord);
-    LOG(IconDatabase, "Releasing pageURL %s to a retain count of %i", urlForLogging(pageURLOriginal).ascii().data(), pageRecord->retainCount() - 1);
+    LOG_INFO(IconDatabase, "Releasing pageURL %s to a retain count of %i", urlForLogging(pageURLOriginal).ascii().data(), pageRecord->retainCount() - 1);
     ASSERT(pageRecord->retainCount() > 0);
         
     // If it still has a positive retain count, store the new count and bail
     if (pageRecord->release(releaseCount))
         return;
         
     // This pageRecord has now been fully released.  Do the appropriate cleanup
-    LOG(IconDatabase, "No more retainers for PageURL %s", urlForLogging(pageURLOriginal).ascii().data());
+    LOG_INFO(IconDatabase, "No more retainers for PageURL %s", urlForLogging(pageURLOriginal).ascii().data());
     m_pageURLToRecordMap.remove(pageURLOriginal);
     m_retainedPageURLs.remove(pageURLOriginal);       
     
     // Grab the iconRecord for later use (and do a sanity check on it for kicks)
     IconRecord* iconRecord = pageRecord->iconRecord();
     
     ASSERT(!iconRecord || (iconRecord && m_iconURLToRecordMap.get(iconRecord->iconURL()) == iconRecord));
 
     {
         MutexLocker locker(m_pendingReadingLock);
@@ skipping 58 matching lines @@
         pageURLs.appendRange(icon->retainingPageURLs().begin(), icon->retainingPageURLs().end());
         
         // Mark the IconRecord as requiring an update to the database only if private browsing is disabled
         if (!m_privateBrowsingEnabled) {
             MutexLocker locker(m_pendingSyncLock);
             m_iconsPendingSync.set(iconURL, icon->snapshot());
         }
 
         if (icon->hasOneRef()) {
             ASSERT(icon->retainingPageURLs().isEmpty());
-            LOG(IconDatabase, "Icon for icon url %s is about to be destroyed - removing mapping for it", urlForLogging(icon->iconURL()).ascii().data());
+            LOG_INFO(IconDatabase, "Icon for icon url %s is about to be destroyed - removing mapping for it", urlForLogging(icon->iconURL()).ascii().data());
             m_iconURLToRecordMap.remove(icon->iconURL());
         }
     }
 
     // Send notification out regarding all PageURLs that retain this icon
     // But not if we're on the sync thread because that implies this mapping
     // comes from the initial import which we don't want notifications for
     if (!IS_ICON_SYNC_THREAD()) {
         // Start the timer to commit this change - or further delay the timer if it was already started
         scheduleOrDeferSyncTimer();
 
         // Informal testing shows that draining the autorelease pool every 25 iterations is about as low as we can go
         // before performance starts to drop off, but we don't want to increase this number because then accumulated memory usage will go up        
         AutodrainedPool pool(25);
 
         for (unsigned i = 0; i < pageURLs.size(); ++i) {
-            LOG(IconDatabase, "Dispatching notification that retaining pageURL %s has a new icon", urlForLogging(pageURLs[i]).ascii().data());
+            LOG_INFO(IconDatabase, "Dispatching notification that retaining pageURL %s has a new icon", urlForLogging(pageURLs[i]).ascii().data());
             m_client->didChangeIconForPageURL(pageURLs[i]);
 
             pool.cycle();
         }
     }
 }
 
 void IconDatabase::setIconURLForPageURL(const String& iconURLOriginal, const String& pageURLOriginal)
 {    
     ASSERT_NOT_SYNC_THREAD();
@@ skipping 27 matching lines @@
 
         RefPtr<IconRecord> iconRecord = pageRecord->iconRecord();
 
         // Otherwise, set the new icon record for this page
         pageRecord->setIconRecord(getOrCreateIconRecord(iconURL));
 
         // If the current icon has only a single ref left, it is about to get wiped out. 
         // Remove it from the in-memory records and don't bother reading it in from disk anymore
         if (iconRecord && iconRecord->hasOneRef()) {
             ASSERT(iconRecord->retainingPageURLs().size() == 0);
-            LOG(IconDatabase, "Icon for icon url %s is about to be destroyed - removing mapping for it", urlForLogging(iconRecord->iconURL()).ascii().data());
+            LOG_INFO(IconDatabase, "Icon for icon url %s is about to be destroyed - removing mapping for it", urlForLogging(iconRecord->iconURL()).ascii().data());
             m_iconURLToRecordMap.remove(iconRecord->iconURL());
             MutexLocker locker(m_pendingReadingLock);
             m_iconsPendingReading.remove(iconRecord.get());
         }
         
         // And mark this mapping to be added to the database
         if (!m_privateBrowsingEnabled) {
             MutexLocker locker(m_pendingSyncLock);
             m_pageURLsPendingSync.set(pageURL, pageRecord->snapshot());
             
             // If the icon is on its last ref, mark it for deletion
             if (iconRecord && iconRecord->hasOneRef())
                 m_iconsPendingSync.set(iconRecord->iconURL(), iconRecord->snapshot(true));
         }
     }
 
     // Since this mapping is new, send the notification out - but not if we're on the sync thread because that implies this mapping
     // comes from the initial import which we don't want notifications for
     if (!IS_ICON_SYNC_THREAD()) {
         // Start the timer to commit this change - or further delay the timer if it was already started
         scheduleOrDeferSyncTimer();
         
-        LOG(IconDatabase, "Dispatching notification that we changed an icon mapping for url %s", urlForLogging(pageURL).ascii().data());
+        LOG_INFO(IconDatabase, "Dispatching notification that we changed an icon mapping for url %s", urlForLogging(pageURL).ascii().data());
         AutodrainedPool pool;
         m_client->didChangeIconForPageURL(pageURL);
     }
 }
 
 IconLoadDecision IconDatabase::synchronousLoadDecisionForIconURL(const String& iconURL, DocumentLoader* notificationDocumentLoader)
 {
     ASSERT_NOT_SYNC_THREAD();
 
     if (!isOpen() || iconURL.isEmpty())
         return IconLoadNo;
     
     // If we have a IconRecord, it should also have its timeStamp marked because there is only two times when we create the IconRecord:
     // 1 - When we read the icon urls from disk, getting the timeStamp at the same time
     // 2 - When we get a new icon from the loader, in which case the timestamp is set at that time
     {
         MutexLocker locker(m_urlAndIconLock);
         if (IconRecord* icon = m_iconURLToRecordMap.get(iconURL)) {
-            LOG(IconDatabase, "Found expiration time on a present icon based on existing IconRecord");
+            LOG_INFO(IconDatabase, "Found expiration time on a present icon based on existing IconRecord");
             return static_cast<int>(currentTime()) - static_cast<int>(icon->getTimestamp()) > iconExpirationTime ? IconLoadYes : IconLoadNo;
         }
     }
     
     // If we don't have a record for it, but we *have* imported all iconURLs from disk, then we should load it now
     MutexLocker readingLocker(m_pendingReadingLock);
     if (m_iconURLImportComplete)
         return IconLoadYes;
         
     // Otherwise - since we refuse to perform I/O on the main thread to find out for sure - we return the answer that says
     // "You might be asked to load this later, so flag that"
-    LOG(IconDatabase, "Don't know if we should load %s or not - adding %p to the set of document loaders waiting on a decision", iconURL.ascii().data(), notificationDocumentLoader);
+    LOG_INFO(IconDatabase, "Don't know if we should load %s or not - adding %p to the set of document loaders waiting on a decision", iconURL.ascii().data(), notificationDocumentLoader);
     if (notificationDocumentLoader)
         m_loadersPendingDecision.add(notificationDocumentLoader);    
 
     return IconLoadUnknown;
 }
 
 bool IconDatabase::synchronousIconDataKnownForIconURL(const String& iconURL)
 {
     ASSERT_NOT_SYNC_THREAD();
     
@@ skipping 27 matching lines @@
 
 bool IconDatabase::isPrivateBrowsingEnabled() const
 {
     return m_privateBrowsingEnabled;
 }
 
 void IconDatabase::delayDatabaseCleanup()
 {
     ++databaseCleanupCounter;
     if (databaseCleanupCounter == 1)
-        LOG(IconDatabase, "Database cleanup is now DISABLED");
+        LOG_INFO(IconDatabase, "Database cleanup is now DISABLED");
 }
 
 void IconDatabase::allowDatabaseCleanup()
 {
     if (--databaseCleanupCounter < 0)
         databaseCleanupCounter = 0;
     if (databaseCleanupCounter == 0)
-        LOG(IconDatabase, "Database cleanup is now ENABLED");
+        LOG_INFO(IconDatabase, "Database cleanup is now ENABLED");
 }
 
 void IconDatabase::checkIntegrityBeforeOpening()
 {
     checkIntegrityOnOpen = true;
 }
 
 size_t IconDatabase::pageURLMappingCount()
 {
     MutexLocker locker(m_urlAndIconLock);
@@ skipping 35 matching lines @@
     , m_privateBrowsingEnabled(false)
     , m_threadTerminationRequested(false)
     , m_removeIconsRequested(false)
     , m_iconURLImportComplete(false)
     , m_syncThreadHasWorkToDo(false)
     , m_disabledSuddenTerminationForSyncThread(false)
     , m_retainOrReleaseIconRequested(false)
     , m_initialPruningComplete(false)
     , m_client(defaultClient())
 {
-    LOG(IconDatabase, "Creating IconDatabase %p", this);
+    LOG_INFO(IconDatabase, "Creating IconDatabase %p", this);
     ASSERT(isMainThread());
 }
 
 IconDatabase::~IconDatabase()
 {
     ASSERT(!isOpen());
 }
 
 void IconDatabase::notifyPendingLoadDecisionsOnMainThread(void* context)
 {
     static_cast<IconDatabase*>(context)->notifyPendingLoadDecisions();
 }
 
 void IconDatabase::notifyPendingLoadDecisions()
 {
     ASSERT_NOT_SYNC_THREAD();
     
     // This method should only be called upon completion of the initial url import from the database
     ASSERT(m_iconURLImportComplete);
-    LOG(IconDatabase, "Notifying all DocumentLoaders that were waiting on a load decision for their icons");
+    LOG_INFO(IconDatabase, "Notifying all DocumentLoaders that were waiting on a load decision for their icons");
     
     HashSet<RefPtr<DocumentLoader> >::iterator i = m_loadersPendingDecision.begin();
     HashSet<RefPtr<DocumentLoader> >::iterator end = m_loadersPendingDecision.end();
     
     for (; i != end; ++i)
         if ((*i)->refCount() > 1)
             (*i)->iconLoadDecisionAvailable();
             
     m_loadersPendingDecision.clear();
 }
@@ skipping 97 matching lines @@
 
     if (!documentCanHaveIcon(pageURL))
         return 0;
 
     PageURLRecord* pageRecord = m_pageURLToRecordMap.get(pageURL);
     
     MutexLocker locker(m_pendingReadingLock);
     if (!m_iconURLImportComplete) {
         // If the initial import of all URLs hasn't completed and we have no page record, we assume we *might* know about this later and create a record for it
         if (!pageRecord) {
-            LOG(IconDatabase, "Creating new PageURLRecord for pageURL %s", urlForLogging(pageURL).ascii().data());
+            LOG_INFO(IconDatabase, "Creating new PageURLRecord for pageURL %s", urlForLogging(pageURL).ascii().data());
             pageRecord = new PageURLRecord(pageURL);
             m_pageURLToRecordMap.set(pageURL, pageRecord);
         }
 
         // If the pageRecord for this page does not have an iconRecord attached to it, then it is a new pageRecord still awaiting the initial import
         // Mark the URL as "interested in the result of the import" then bail
         if (!pageRecord->iconRecord()) {
             m_pageURLsPendingImport.add(pageURL);
             return 0;
         }
@@ skipping 26 matching lines @@
 {
     // The call to create this thread might not complete before the thread actually starts, so we might fail this ASSERT_ICON_SYNC_THREAD() because the pointer 
     // to our thread structure hasn't been filled in yet.
     // To fix this, the main thread acquires this lock before creating us, then releases the lock after creation is complete.  A quick lock/unlock cycle here will 
     // prevent us from running before that call completes
     m_syncLock.lock();
     m_syncLock.unlock();
 
     ASSERT_ICON_SYNC_THREAD();
     
-    LOG(IconDatabase, "(THREAD) IconDatabase sync thread started");
+    LOG_INFO(IconDatabase, "(THREAD) IconDatabase sync thread started");
 
 #if !LOG_DISABLED
     double startTime = currentTime();
 #endif
 
     // Need to create the database path if it doesn't already exist
     makeAllDirectories(m_databaseDirectory);
 
     // Existence of a journal file is evidence of a previous crash/force quit and automatically qualifies
     // us to do an integrity check
@@ skipping 11 matching lines @@
         }
     }
     
     if (shouldStopThreadActivity()) {
         syncThreadMainLoop();
         return;
     }
         
 #if !LOG_DISABLED
     double timeStamp = currentTime();
-    LOG(IconDatabase, "(THREAD) Open took %.4f seconds", timeStamp - startTime);
+    LOG_INFO(IconDatabase, "(THREAD) Open took %.4f seconds", timeStamp - startTime);
 #endif    
 
     performOpenInitialization();
     if (shouldStopThreadActivity()) {
         syncThreadMainLoop();
         return;
     }
         
 #if !LOG_DISABLED
     double newStamp = currentTime();
-    LOG(IconDatabase, "(THREAD) performOpenInitialization() took %.4f seconds, now %.4f seconds from thread start", newStamp - timeStamp, newStamp - startTime);
+    LOG_INFO(IconDatabase, "(THREAD) performOpenInitialization() took %.4f seconds, now %.4f seconds from thread start", newStamp - timeStamp, newStamp - startTime);
     timeStamp = newStamp;
 #endif 
         
     // Uncomment the following line to simulate a long lasting URL import (*HUGE* icon databases, or network home directories)
     // while (currentTime() - timeStamp < 10);
 
     // Read in URL mappings from the database          
-    LOG(IconDatabase, "(THREAD) Starting iconURL import");
+    LOG_INFO(IconDatabase, "(THREAD) Starting iconURL import");
     performURLImport();
     
     if (shouldStopThreadActivity()) {
         syncThreadMainLoop();
         return;
     }
 
 #if !LOG_DISABLED
     newStamp = currentTime();
-    LOG(IconDatabase, "(THREAD) performURLImport() took %.4f seconds.  Entering main loop %.4f seconds from thread start", newStamp - timeStamp, newStamp - startTime);
+    LOG_INFO(IconDatabase, "(THREAD) performURLImport() took %.4f seconds.  Entering main loop %.4f seconds from thread start", newStamp - timeStamp, newStamp - startTime);
 #endif 
 
-    LOG(IconDatabase, "(THREAD) Beginning sync");
+    LOG_INFO(IconDatabase, "(THREAD) Beginning sync");
     syncThreadMainLoop();
 }
 
 static int databaseVersionNumber(SQLiteDatabase& db)
 {
     return SQLiteStatement(db, "SELECT value FROM IconDatabaseInfo WHERE key = 'Version';").getColumnInt(0);
 }
 
 static bool isValidDatabase(SQLiteDatabase& db)
 {
     // These four tables should always exist in a valid db
     if (!db.tableExists("IconInfo") || !db.tableExists("IconData") || !db.tableExists("PageURL") || !db.tableExists("IconDatabaseInfo"))
         return false;
     
     if (databaseVersionNumber(db) < currentDatabaseVersion) {
-        LOG(IconDatabase, "DB version is not found or below expected valid version");
+        LOG_INFO(IconDatabase, "DB version is not found or below expected valid version");
         return false;
     }
     
     return true;
 }
 
 static void createDatabaseTables(SQLiteDatabase& db)
 {
     if (!db.executeCommand("CREATE TABLE PageURL (url TEXT NOT NULL ON CONFLICT FAIL UNIQUE ON CONFLICT REPLACE,iconID INTEGER NOT NULL ON CONFLICT FAIL);")) {
         LOG_ERROR("Could not create PageURL table in database (%i) - %s", db.lastError(), db.lastErrorMsg());
@@ skipping 40 matching lines @@
 void IconDatabase::performOpenInitialization()
 {
     ASSERT_ICON_SYNC_THREAD();
     
     if (!isOpen())
         return;
     
     if (checkIntegrityOnOpen) {
         checkIntegrityOnOpen = false;
         if (!checkIntegrity()) {
-            LOG(IconDatabase, "Integrity check was bad - dumping IconDatabase");
+            LOG_INFO(IconDatabase, "Integrity check was bad - dumping IconDatabase");
 
             m_syncDB.close();
             
             {
                 MutexLocker locker(m_syncLock);
                 // Should've been consumed by SQLite, delete just to make sure we don't see it again in the future;
                 deleteFile(m_completeDatabasePath + "-journal");
                 deleteFile(m_completeDatabasePath);
             }
             
             // Reopen the write database, creating it from scratch
             if (!m_syncDB.open(m_completeDatabasePath)) {
                 LOG_ERROR("Unable to open icon database at path %s - %s", m_completeDatabasePath.ascii().data(), m_syncDB.lastErrorMsg());
                 return;
             }          
         }
     }
     
     int version = databaseVersionNumber(m_syncDB);
     
     if (version > currentDatabaseVersion) {
-        LOG(IconDatabase, "Database version number %i is greater than our current version number %i - closing the database to prevent overwriting newer versions", version, currentDatabaseVersion);
+        LOG_INFO(IconDatabase, "Database version number %i is greater than our current version number %i - closing the database to prevent overwriting newer versions", version, currentDatabaseVersion);
         m_syncDB.close();
         m_threadTerminationRequested = true;
         return;
     }
     
     if (!isValidDatabase(m_syncDB)) {
-        LOG(IconDatabase, "%s is missing or in an invalid state - reconstructing", m_completeDatabasePath.ascii().data());
+        LOG_INFO(IconDatabase, "%s is missing or in an invalid state - reconstructing", m_completeDatabasePath.ascii().data());
         m_syncDB.clearAllTables();
         createDatabaseTables(m_syncDB);
     }
 
     // Reduce sqlite RAM cache size from default 2000 pages (~1.5kB per page). 3MB of cache for icon database is overkill
     if (!SQLiteStatement(m_syncDB, "PRAGMA cache_size = 200;").executeCommand())         
         LOG_ERROR("SQLite database could not set cache_size");
 
     // Tell backup software (i.e., Time Machine) to never back up the icon database, because  
     // it's a large file that changes frequently, thus using a lot of backup disk space, and 
@@ skipping 104 matching lines @@
             if (m_pageURLsPendingImport.contains(pageURL)) {
                 dispatchDidImportIconURLForPageURLOnMainThread(pageURL);
                 m_pageURLsPendingImport.remove(pageURL);
             
                 pool.cycle();
             }
         }
         
         // Stop the import at any time of the thread has been asked to shutdown
         if (shouldStopThreadActivity()) {
-            LOG(IconDatabase, "IconDatabase asked to terminate during performURLImport()");
+            LOG_INFO(IconDatabase, "IconDatabase asked to terminate during performURLImport()");
             return;
         }
         
         result = query.step();
     }
     
     if (result != SQLResultDone)
-        LOG(IconDatabase, "Error reading page->icon url mappings from database");
+        LOG_INFO(IconDatabase, "Error reading page->icon url mappings from database");
 
     // Clear the m_pageURLsPendingImport set - either the page URLs ended up with an iconURL (that we'll notify about) or not, 
     // but after m_iconURLImportComplete is set to true, we don't care about this set anymore
     Vector<String> urls;
     {
         MutexLocker locker(m_pendingReadingLock);
 
         urls.appendRange(m_pageURLsPendingImport.begin(), m_pageURLsPendingImport.end());
         m_pageURLsPendingImport.clear();        
         m_iconURLImportComplete = true;
@@ skipping 33 matching lines @@
                     }
                     
                     delete record;
                 }
             } else {
                 urlsToNotify.append(urls[i]);
             }
         }
     }
 
-    LOG(IconDatabase, "Notifying %lu interested page URLs that their icon URL is known due to the import", static_cast<unsigned long>(urlsToNotify.size()));
+    LOG_INFO(IconDatabase, "Notifying %lu interested page URLs that their icon URL is known due to the import", static_cast<unsigned long>(urlsToNotify.size()));
     // Now that we don't hold any locks, perform the actual notifications
     for (unsigned i = 0; i < urlsToNotify.size(); ++i) {
-        LOG(IconDatabase, "Notifying icon info known for pageURL %s", urlsToNotify[i].ascii().data());
+        LOG_INFO(IconDatabase, "Notifying icon info known for pageURL %s", urlsToNotify[i].ascii().data());
         dispatchDidImportIconURLForPageURLOnMainThread(urlsToNotify[i]);
         if (shouldStopThreadActivity())
             return;
 
         pool.cycle();
     }
     
     // Notify the client that the URL import is complete in case it's managing its own pending notifications.
     dispatchDidFinishURLImportOnMainThread();
     
@@ skipping 14 matching lines @@
     // without doing any work. Either way we're dealing with any currently-pending work.
     m_syncThreadHasWorkToDo = false;
 
     // It's possible thread termination is requested before the main loop even starts - in that case, just skip straight to cleanup
     while (!m_threadTerminationRequested) {
         m_syncLock.unlock();
 
 #if !LOG_DISABLED
         double timeStamp = currentTime();
 #endif
-        LOG(IconDatabase, "(THREAD) Main work loop starting");
+        LOG_INFO(IconDatabase, "(THREAD) Main work loop starting");
 
         // If we should remove all icons, do it now.  This is an uninteruptible procedure that we will always do before quitting if it is requested
         if (m_removeIconsRequested) {
             removeAllIconsOnThread();
             m_removeIconsRequested = false;
         }
         
         // Then, if the thread should be quitting, quit now!
         if (m_threadTerminationRequested)
             break;
@@ skipping 17 matching lines @@
             // This way, pruning won't be the only operation we perform to the database by itself
             // We also don't want to bother doing this if the thread should be terminating (the user is quitting)
             // or if private browsing is enabled
             // We also don't want to prune if the m_databaseCleanupCounter count is non-zero - that means someone
             // has asked to delay pruning
             static bool prunedUnretainedIcons = false;
             if (didWrite && !m_privateBrowsingEnabled && !prunedUnretainedIcons && !databaseCleanupCounter) {
 #if !LOG_DISABLED
                 double time = currentTime();
 #endif
-                LOG(IconDatabase, "(THREAD) Starting pruneUnretainedIcons()");
+                LOG_INFO(IconDatabase, "(THREAD) Starting pruneUnretainedIcons()");
                 
                 pruneUnretainedIcons();
                 
-                LOG(IconDatabase, "(THREAD) pruneUnretainedIcons() took %.4f seconds", currentTime() - time);
+                LOG_INFO(IconDatabase, "(THREAD) pruneUnretainedIcons() took %.4f seconds", currentTime() - time);
                 
                 // If pruneUnretainedIcons() returned early due to requested thread termination, its still okay
                 // to mark prunedUnretainedIcons true because we're about to terminate anyway
                 prunedUnretainedIcons = true;
             }
             
             didAnyWork = didAnyWork || didWrite;
             if (shouldStopThreadActivity())
                 break;
         }
         
 #if !LOG_DISABLED
         double newstamp = currentTime();
-        LOG(IconDatabase, "(THREAD) Main work loop ran for %.4f seconds, %s requested to terminate", newstamp - timeStamp, shouldStopThreadActivity() ? "was" : "was not");
+        LOG_INFO(IconDatabase, "(THREAD) Main work loop ran for %.4f seconds, %s requested to terminate", newstamp - timeStamp, shouldStopThreadActivity() ? "was" : "was not");
 #endif
                     
         m_syncLock.lock();
         
         // There is some condition that is asking us to stop what we're doing now and handle a special case
         // This is either removing all icons, or shutting down the thread to quit the app
         // We handle those at the top of this main loop so continue to jump back up there
         if (shouldStopThreadActivity())
             continue;
 
@@ skipping 112 matching lines @@
                         innerHash = &(icons[i]->retainingPageURLs());
                     } else {
                         innerHash = &m_pageURLsInterestedInIcons;
                         outerHash = &(icons[i]->retainingPageURLs());
                     }
                     
                     HashSet<String>::const_iterator iter = outerHash->begin();
                     HashSet<String>::const_iterator end = outerHash->end();
                     for (; iter != end; ++iter) {
                         if (innerHash->contains(*iter)) {
-                            LOG(IconDatabase, "%s is interested in the icon we just read. Adding it to the notification list and removing it from the interested set", urlForLogging(*iter).ascii().data());
+                            LOG_INFO(IconDatabase, "%s is interested in the icon we just read. Adding it to the notification list and removing it from the interested set", urlForLogging(*iter).ascii().data());
                             urlsToNotify.add(*iter);
                         }
                         
                         // If we ever get to the point were we've seen every url interested in this icon, break early
                         if (urlsToNotify.size() == m_pageURLsInterestedInIcons.size())
                             break;
                     }
                     
                     // We don't need to notify a PageURL twice, so all the ones we're about to notify can be removed from the interested set
                     if (urlsToNotify.size() == m_pageURLsInterestedInIcons.size())
@@ skipping 12 matching lines @@
             return didAnyWork;
         
         // Informal testing shows that draining the autorelease pool every 25 iterations is about as low as we can go
         // before performance starts to drop off, but we don't want to increase this number because then accumulated memory usage will go up
         AutodrainedPool pool(25);
 
         // Now that we don't hold any locks, perform the actual notifications
         HashSet<String>::iterator iter = urlsToNotify.begin();
         HashSet<String>::iterator end = urlsToNotify.end();
         for (unsigned iteration = 0; iter != end; ++iter, ++iteration) {
-            LOG(IconDatabase, "Notifying icon received for pageURL %s", urlForLogging(*iter).ascii().data());
+            LOG_INFO(IconDatabase, "Notifying icon received for pageURL %s", urlForLogging(*iter).ascii().data());
             dispatchDidImportIconDataForPageURLOnMainThread(*iter);
             if (shouldStopThreadActivity())
                 return didAnyWork;
             
             pool.cycle();
         }
 
-        LOG(IconDatabase, "Done notifying %i pageURLs who just received their icons", urlsToNotify.size());
+        LOG_INFO(IconDatabase, "Done notifying %i pageURLs who just received their icons", urlsToNotify.size());
         urlsToNotify.clear();
         
         if (shouldStopThreadActivity())
             return didAnyWork;
     }
 
-    LOG(IconDatabase, "Reading from database took %.4f seconds", currentTime() - timeStamp);
+    LOG_INFO(IconDatabase, "Reading from database took %.4f seconds", currentTime() - timeStamp);
 
     return didAnyWork;
 }
 
 bool IconDatabase::writeToDatabase()
 {
     ASSERT_ICON_SYNC_THREAD();
 
 #if !LOG_DISABLED
     double timeStamp = currentTime();
@@ skipping 19 matching lines @@
         }
 
         if (iconSnapshots.size() || pageSnapshots.size())
             didAnyWork = true;
 
         SQLiteTransaction syncTransaction(m_syncDB);
         syncTransaction.begin();
 
         for (unsigned i = 0; i < iconSnapshots.size(); ++i) {
             writeIconSnapshotToSQLDatabase(iconSnapshots[i]);
-            LOG(IconDatabase, "Wrote IconRecord for IconURL %s with timeStamp of %i to the DB", urlForLogging(iconSnapshots[i].iconURL()).ascii().data(), iconSnapshots[i].timestamp());
+            LOG_INFO(IconDatabase, "Wrote IconRecord for IconURL %s with timeStamp of %i to the DB", urlForLogging(iconSnapshots[i].iconURL()).ascii().data(), iconSnapshots[i].timestamp());
         }
 
         for (unsigned i = 0; i < pageSnapshots.size(); ++i) {
             // If the icon URL is empty, this page is meant to be deleted
             // ASSERTs are sanity checks to make sure the mappings exist if they should and don't if they shouldn't
             if (pageSnapshots[i].iconURL().isEmpty())
                 removePageURLFromSQLDatabase(pageSnapshots[i].pageURL());
             else
                 setIconURLForPageURLInSQLDatabase(pageSnapshots[i].iconURL(), pageSnapshots[i].pageURL());
-            LOG(IconDatabase, "Committed IconURL for PageURL %s to database", urlForLogging(pageSnapshots[i].pageURL()).ascii().data());
+            LOG_INFO(IconDatabase, "Committed IconURL for PageURL %s to database", urlForLogging(pageSnapshots[i].pageURL()).ascii().data());
         }
 
         syncTransaction.commit();
     }
 
     // Check to make sure there are no dangling PageURLs - If there are, we want to output one log message but not spam the console potentially every few seconds
     if (didAnyWork)
         checkForDanglingPageURLs(false);
 
-    LOG(IconDatabase, "Updating the database took %.4f seconds", currentTime() - timeStamp);
+    LOG_INFO(IconDatabase, "Updating the database took %.4f seconds", currentTime() - timeStamp);
 
     return didAnyWork;
 }
 
 void IconDatabase::pruneUnretainedIcons()
 {
     ASSERT_ICON_SYNC_THREAD();
 
     if (!isOpen())
         return;        
@@ skipping 24 matching lines @@
     // Delete page URLs that were in the table, but not in our retain count set.
     size_t numToDelete = pageIDsToDelete.size();
     if (numToDelete) {
         SQLiteTransaction pruningTransaction(m_syncDB);
         pruningTransaction.begin();
         
         SQLiteStatement pageDeleteSQL(m_syncDB, "DELETE FROM PageURL WHERE rowid = (?);");
         pageDeleteSQL.prepare();
         for (size_t i = 0; i < numToDelete; ++i) {
 #if OS(WINDOWS)
-            LOG(IconDatabase, "Pruning page with rowid %I64i from disk", static_cast<long long>(pageIDsToDelete[i]));
+            LOG_INFO(IconDatabase, "Pruning page with rowid %I64i from disk", static_cast<long long>(pageIDsToDelete[i]));
 #else
-            LOG(IconDatabase, "Pruning page with rowid %lli from disk", static_cast<long long>(pageIDsToDelete[i]));
+            LOG_INFO(IconDatabase, "Pruning page with rowid %lli from disk", static_cast<long long>(pageIDsToDelete[i]));
 #endif
             pageDeleteSQL.bindInt64(1, pageIDsToDelete[i]);
             int result = pageDeleteSQL.step();
             if (result != SQLResultDone)
 #if OS(WINDOWS)
                 LOG_ERROR("Unabled to delete page with id %I64i from disk", static_cast<long long>(pageIDsToDelete[i]));
 #else
                 LOG_ERROR("Unabled to delete page with id %lli from disk", static_cast<long long>(pageIDsToDelete[i]));
 #endif
             pageDeleteSQL.reset();
@@ skipping 37 matching lines @@
     // entries.  We also don't want to keep performing this check and reporting this error if it has already found danglers before so we
     // keep track of whether we've found any.  We skip the check in the release build pretending to have already found danglers already.
 #ifndef NDEBUG
     static bool danglersFound = true;
 #else
     static bool danglersFound = false;
 #endif
 
     if ((pruneIfFound || !danglersFound) && SQLiteStatement(m_syncDB, "SELECT url FROM PageURL WHERE PageURL.iconID NOT IN (SELECT iconID FROM IconInfo) LIMIT 1;").returnsAtLeastOneResult()) {
         danglersFound = true;
-        LOG(IconDatabase, "Dangling PageURL entries found");
+        LOG_INFO(IconDatabase, "Dangling PageURL entries found");
         if (pruneIfFound && !m_syncDB.executeCommand("DELETE FROM PageURL WHERE iconID NOT IN (SELECT iconID FROM IconInfo);"))
-            LOG(IconDatabase, "Unable to prune dangling PageURLs");
+            LOG_INFO(IconDatabase, "Unable to prune dangling PageURLs");
     }
 }
 
 void IconDatabase::removeAllIconsOnThread()
 {
     ASSERT_ICON_SYNC_THREAD();
 
-    LOG(IconDatabase, "Removing all icons on the sync thread");
+    LOG_INFO(IconDatabase, "Removing all icons on the sync thread");
         
     // Delete all the prepared statements so they can start over
     deleteAllPreparedStatements();    
     
     // To reset the on-disk database, we'll wipe all its tables then vacuum it
     // This is easier and safer than closing it, deleting the file, and recreating from scratch
     m_syncDB.clearAllTables();
     m_syncDB.runVacuumCommand();
     createDatabaseTables(m_syncDB);
     
-    LOG(IconDatabase, "Dispatching notification that we removed all icons");
+    LOG_INFO(IconDatabase, "Dispatching notification that we removed all icons");
     dispatchDidRemoveAllIconsOnMainThread();    
 }
 
 void IconDatabase::deleteAllPreparedStatements()
 {
     ASSERT_ICON_SYNC_THREAD();
     
     m_setIconIDForPageURLStatement.clear();
     m_removePageURLStatement.clear();
     m_getIconIDForIconURLStatement.clear();
@@ skipping 16 matching lines @@
     
 #if !LOG_DISABLED
     double timeStamp = currentTime();
 #endif 
 
     // If the removeIcons flag is set, remove all icons from the db.
     if (m_removeIconsRequested)
         removeAllIconsOnThread();
 
     // Sync remaining icons out
-    LOG(IconDatabase, "(THREAD) Doing final writeout and closure of sync thread");
+    LOG_INFO(IconDatabase, "(THREAD) Doing final writeout and closure of sync thread");
     writeToDatabase();
     
     // Close the database
     MutexLocker locker(m_syncLock);
     
     m_databaseDirectory = String();
     m_completeDatabasePath = String();
     deleteAllPreparedStatements();    
     m_syncDB.close();
     
 #if !LOG_DISABLED
-    LOG(IconDatabase, "(THREAD) Final closure took %.4f seconds", currentTime() - timeStamp);
+    LOG_INFO(IconDatabase, "(THREAD) Final closure took %.4f seconds", currentTime() - timeStamp);
 #endif
     
     m_syncThreadRunning = false;
     return 0;
 }
 
 // readySQLiteStatement() handles two things
 // 1 - If the SQLDatabase& argument is different, the statement must be destroyed and remade.  This happens when the user
 //     switches to and from private browsing
 // 2 - Lazy construction of the Statement in the first place, in case we've never made this query before
 inline void readySQLiteStatement(OwnPtr<SQLiteStatement>& statement, SQLiteDatabase& db, const String& str)
 {
     if (statement && (statement->database() != &db || statement->isExpired())) {
         if (statement->isExpired())
-            LOG(IconDatabase, "SQLiteStatement associated with %s is expired", str.ascii().data());
+            LOG_INFO(IconDatabase, "SQLiteStatement associated with %s is expired", str.ascii().data());
         statement.clear();
     }
     if (!statement) {
         statement = adoptPtr(new SQLiteStatement(db, str));
         if (statement->prepare() != SQLResultOk)
             LOG_ERROR("Preparing statement %s failed", str.ascii().data());
     }
 }
 
 void IconDatabase::setIconURLForPageURLInSQLDatabase(const String& iconURL, const String& pageURL)
@@ skipping 160 matching lines @@
 
 void IconDatabase::writeIconSnapshotToSQLDatabase(const IconSnapshot& snapshot)
 {
     ASSERT_ICON_SYNC_THREAD();
     
     if (snapshot.iconURL().isEmpty())
         return;
         
     // A nulled out timestamp and data means this icon is destined to be deleted - do that instead of writing it out
     if (!snapshot.timestamp() && !snapshot.data()) {
-        LOG(IconDatabase, "Removing %s from on-disk database", urlForLogging(snapshot.iconURL()).ascii().data());
+        LOG_INFO(IconDatabase, "Removing %s from on-disk database", urlForLogging(snapshot.iconURL()).ascii().data());
         removeIconFromSQLDatabase(snapshot.iconURL());
         return;
     }
 
     // There would be a transaction here to make sure these removals are atomic
     // In practice the only caller of this method is always wrapped in a transaction itself so placing another here is unnecessary
         
     // Get the iconID for this url
     int64_t iconID = getIconIDForIconURLFromSQLDatabase(snapshot.iconURL());
     
@@ skipping 190 matching lines @@
     ASSERT_ICON_SYNC_THREAD();
 
     FinishedURLImport* work = new FinishedURLImport(m_client);
     callOnMainThread(performWorkItem, work);
 }
 
 
 } // namespace WebCore
 
 #endif // ENABLE(ICONDATABASE)