Rename LOG() to LOG_INFO()

Source/WebCore/loader/ResourceLoadScheduler.cpp

 /*
     Copyright (C) 1998 Lars Knoll (knoll@mpi-hd.mpg.de)
     Copyright (C) 2001 Dirk Mueller (mueller@kde.org)
     Copyright (C) 2002 Waldo Bastian (bastian@kde.org)
     Copyright (C) 2006 Samuel Weinig (sam.weinig@gmail.com)
     Copyright (C) 2004, 2005, 2006, 2007, 2008 Apple Inc. All rights reserved.
     Copyright (C) 2010 Google Inc. All rights reserved.
 
     This library is free software; you can redistribute it and/or
     modify it under the terms of the GNU Library General Public
@@ skipping 122 matching lines @@
 }
 
 void ResourceLoadScheduler::scheduleLoad(ResourceLoader* resourceLoader, ResourceLoadPriority priority)
 {
     ASSERT(resourceLoader);
     ASSERT(priority != ResourceLoadPriorityUnresolved);
 #if !REQUEST_MANAGEMENT_ENABLED
     priority = ResourceLoadPriorityHighest;
 #endif
 
-    LOG(ResourceLoading, "ResourceLoadScheduler::load resource %p '%s'", resourceLoader, resourceLoader->url().string().latin1().data());
+    LOG_INFO(ResourceLoading, "ResourceLoadScheduler::load resource %p '%s'", resourceLoader, resourceLoader->url().string().latin1().data());
 
     // If there's a web archive resource for this URL, we don't need to schedule the load since it will never touch the network.
     if (resourceLoader->documentLoader()->archiveResourceForURL(resourceLoader->request().url())) {
         resourceLoader->start();
         return;
     }
 
     HostInformation* host = hostForURL(resourceLoader->url(), CreateIfNotFound);    
     bool hadRequests = host->hasRequests();
     host->schedule(resourceLoader, priority);
@@ skipping 34 matching lines @@
 
     if (oldHost->name() == newHost->name())
         return;
     
     newHost->addLoadInProgress(resourceLoader);
     oldHost->remove(resourceLoader);
 }
 
 void ResourceLoadScheduler::servePendingRequests(ResourceLoadPriority minimumPriority)
 {
-    LOG(ResourceLoading, "ResourceLoadScheduler::servePendingRequests. m_suspendPendingRequestsCount=%d", m_suspendPendingRequestsCount); 
+    LOG_INFO(ResourceLoading, "ResourceLoadScheduler::servePendingRequests. m_suspendPendingRequestsCount=%d", m_suspendPendingRequestsCount);
     if (isSuspendingPendingRequests())
         return;
 
     m_requestTimer.stop();
     
     servePendingRequests(m_nonHTTPProtocolHost, minimumPriority);
 
     Vector<HostInformation*> hostsToServe;
     m_hosts.checkConsistency();
     HostMap::iterator end = m_hosts.end();
     for (HostMap::iterator iter = m_hosts.begin(); iter != end; ++iter)
         hostsToServe.append(iter->value);
 
     int size = hostsToServe.size();
     for (int i = 0; i < size; ++i) {
         HostInformation* host = hostsToServe[i];
         if (host->hasRequests())
             servePendingRequests(host, minimumPriority);
         else
             delete m_hosts.take(host->name());
     }
 }
 
 void ResourceLoadScheduler::servePendingRequests(HostInformation* host, ResourceLoadPriority minimumPriority)
 {
-    LOG(ResourceLoading, "ResourceLoadScheduler::servePendingRequests HostInformation.m_name='%s'", host->name().latin1().data());
+    LOG_INFO(ResourceLoading, "ResourceLoadScheduler::servePendingRequests HostInformation.m_name='%s'", host->name().latin1().data());
 
     for (int priority = ResourceLoadPriorityHighest; priority >= minimumPriority; --priority) {
         HostInformation::RequestQueue& requestsPending = host->requestsPending(ResourceLoadPriority(priority));
 
         while (!requestsPending.isEmpty()) {
             RefPtr<ResourceLoader> resourceLoader = requestsPending.first();
 
             // For named hosts - which are only http(s) hosts - we should always enforce the connection limit.
             // For non-named hosts - everything but http(s) - we should only enforce the limit if the document isn't done parsing 
             // and we don't know all stylesheets yet.
@@ skipping 19 matching lines @@
     ASSERT(m_suspendPendingRequestsCount);
     --m_suspendPendingRequestsCount;
     if (m_suspendPendingRequestsCount)
         return;
     if (!m_hosts.isEmpty() || m_nonHTTPProtocolHost->hasRequests())
         scheduleServePendingRequests();
 }
     
 void ResourceLoadScheduler::scheduleServePendingRequests()
 {
-    LOG(ResourceLoading, "ResourceLoadScheduler::scheduleServePendingRequests, m_requestTimer.isActive()=%u", m_requestTimer.isActive());
+    LOG_INFO(ResourceLoading, "ResourceLoadScheduler::scheduleServePendingRequests, m_requestTimer.isActive()=%u", m_requestTimer.isActive());
     if (!m_requestTimer.isActive())
         m_requestTimer.startOneShot(0);
 }
 
 void ResourceLoadScheduler::requestTimerFired(Timer<ResourceLoadScheduler>*) 
 {
-    LOG(ResourceLoading, "ResourceLoadScheduler::requestTimerFired\n");
+    LOG_INFO(ResourceLoading, "ResourceLoadScheduler::requestTimerFired\n");
     servePendingRequests();
 }
 
 ResourceLoadScheduler::HostInformation::HostInformation(const String& name, unsigned maxRequestsInFlight)
     : m_name(name)
     , m_maxRequestsInFlight(maxRequestsInFlight)
 {
 }
 
 ResourceLoadScheduler::HostInformation::~HostInformation()
 {
     ASSERT(m_requestsLoading.isEmpty());
     for (unsigned p = 0; p <= ResourceLoadPriorityHighest; p++)
         ASSERT(m_requestsPending[p].isEmpty());
 }
     
 void ResourceLoadScheduler::HostInformation::schedule(ResourceLoader* resourceLoader, ResourceLoadPriority priority)
 {
     m_requestsPending[priority].append(resourceLoader);
 }
     
 void ResourceLoadScheduler::HostInformation::addLoadInProgress(ResourceLoader* resourceLoader)
 {
-    LOG(ResourceLoading, "HostInformation '%s' loading '%s'. Current count %d", m_name.latin1().data(), resourceLoader->url().string().latin1().data(), m_requestsLoading.size());
+    LOG_INFO(ResourceLoading, "HostInformation '%s' loading '%s'. Current count %d", m_name.latin1().data(), resourceLoader->url().string().latin1().data(), m_requestsLoading.size());
     m_requestsLoading.add(resourceLoader);
 }
     
 void ResourceLoadScheduler::HostInformation::remove(ResourceLoader* resourceLoader)
 {
     if (m_requestsLoading.contains(resourceLoader)) {
         m_requestsLoading.remove(resourceLoader);
         return;
     }
     
@@ skipping 20 matching lines @@
 }
 
 bool ResourceLoadScheduler::HostInformation::limitRequests(ResourceLoadPriority priority) const 
 {
     if (priority == ResourceLoadPriorityVeryLow && !m_requestsLoading.isEmpty())
         return true;
     return m_requestsLoading.size() >= (resourceLoadScheduler()->isSerialLoadingEnabled() ? 1 : m_maxRequestsInFlight);
 }
 
 } // namespace WebCore