Rename LOG() to LOG_INFO()

Source/WebCore/loader/archive/cf/LegacyWebArchive.cpp

 /*
  * Copyright (C) 2008, 2009 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 76 matching lines @@
     if (data)
         cfData.adoptCF(data->createCFData());
     else
         cfData.adoptCF(CFDataCreate(0, 0, 0));
     CFDictionarySetValue(propertyList.get(), LegacyWebArchiveResourceDataKey, cfData.get());
     
     // Resource URL cannot be null
     if (RetainPtr<CFStringRef> cfURL = resource->url().string().createCFString())
         CFDictionarySetValue(propertyList.get(), LegacyWebArchiveResourceURLKey, cfURL.get());
     else {
-        LOG(Archives, "LegacyWebArchive - NULL resource URL is invalid - returning null property list");
+        LOG_INFO(Archives, "LegacyWebArchive - NULL resource URL is invalid - returning null property list");
         return 0;
     }
 
     // FrameName should be left out if empty for subresources, but always included for main resources
     const String& frameName(resource->frameName());
     if (!frameName.isEmpty() || isMainResource)
         CFDictionarySetValue(propertyList.get(), LegacyWebArchiveResourceFrameNameKey, frameName.createCFString().get());
     
     // Set MIMEType, TextEncodingName, and ResourceResponse only if they actually exist
     const String& mimeType(resource->mimeType());
@@ skipping 24 matching lines @@
         return 0;
     CFDictionarySetValue(propertyList.get(), LegacyWebArchiveMainResourceKey, mainResourceDict.get());
 
     RetainPtr<CFMutableArrayRef> subresourcesArray(AdoptCF, CFArrayCreateMutable(0, archive->subresources().size(), &kCFTypeArrayCallBacks));
     const Vector<RefPtr<ArchiveResource> >& subresources(archive->subresources());
     for (unsigned i = 0; i < subresources.size(); ++i) {
         RetainPtr<CFDictionaryRef> subresource = createPropertyListRepresentation(subresources[i].get(), Subresource);
         if (subresource)
             CFArrayAppendValue(subresourcesArray.get(), subresource.get());
         else
-            LOG(Archives, "LegacyWebArchive - Failed to create property list for subresource");
+            LOG_INFO(Archives, "LegacyWebArchive - Failed to create property list for subresource");
     }
     if (CFArrayGetCount(subresourcesArray.get()))
         CFDictionarySetValue(propertyList.get(), LegacyWebArchiveSubresourcesKey, subresourcesArray.get());
 
     RetainPtr<CFMutableArrayRef> subframesArray(AdoptCF, CFArrayCreateMutable(0, archive->subframeArchives().size(), &kCFTypeArrayCallBacks));
     const Vector<RefPtr<Archive> >& subframeArchives(archive->subframeArchives());
     for (unsigned i = 0; i < subframeArchives.size(); ++i) {
         RetainPtr<CFDictionaryRef> subframeArchive = createPropertyListRepresentation(subframeArchives[i].get());
         if (subframeArchive)
             CFArrayAppendValue(subframesArray.get(), subframeArchive.get());
         else
-            LOG(Archives, "LegacyWebArchive - Failed to create property list for subframe archive");
+            LOG_INFO(Archives, "LegacyWebArchive - Failed to create property list for subframe archive");
     }
     if (CFArrayGetCount(subframesArray.get()))
         CFDictionarySetValue(propertyList.get(), LegacyWebArchiveSubframeArchivesKey, subframesArray.get());
 
     return propertyList;
 }
 
 ResourceResponse LegacyWebArchive::createResourceResponseFromPropertyListData(CFDataRef data, CFStringRef responseDataType)
 {
     ASSERT(data);
@@ skipping 11 matching lines @@
 }
 
 PassRefPtr<ArchiveResource> LegacyWebArchive::createResource(CFDictionaryRef dictionary)
 {
     ASSERT(dictionary);
     if (!dictionary)
         return 0;
         
     CFDataRef resourceData = static_cast<CFDataRef>(CFDictionaryGetValue(dictionary, LegacyWebArchiveResourceDataKey));
     if (resourceData && CFGetTypeID(resourceData) != CFDataGetTypeID()) {
-        LOG(Archives, "LegacyWebArchive - Resource data is not of type CFData, cannot create invalid resource");
+        LOG_INFO(Archives, "LegacyWebArchive - Resource data is not of type CFData, cannot create invalid resource");
         return 0;
     }
     
     CFStringRef frameName = static_cast<CFStringRef>(CFDictionaryGetValue(dictionary, LegacyWebArchiveResourceFrameNameKey));
     if (frameName && CFGetTypeID(frameName) != CFStringGetTypeID()) {
-        LOG(Archives, "LegacyWebArchive - Frame name is not of type CFString, cannot create invalid resource");
+        LOG_INFO(Archives, "LegacyWebArchive - Frame name is not of type CFString, cannot create invalid resource");
         return 0;
     }
     
     CFStringRef mimeType = static_cast<CFStringRef>(CFDictionaryGetValue(dictionary, LegacyWebArchiveResourceMIMETypeKey));
     if (mimeType && CFGetTypeID(mimeType) != CFStringGetTypeID()) {
-        LOG(Archives, "LegacyWebArchive - MIME type is not of type CFString, cannot create invalid resource");
+        LOG_INFO(Archives, "LegacyWebArchive - MIME type is not of type CFString, cannot create invalid resource");
         return 0;
     }
     
     CFStringRef url = static_cast<CFStringRef>(CFDictionaryGetValue(dictionary, LegacyWebArchiveResourceURLKey));
     if (url && CFGetTypeID(url) != CFStringGetTypeID()) {
-        LOG(Archives, "LegacyWebArchive - URL is not of type CFString, cannot create invalid resource");
+        LOG_INFO(Archives, "LegacyWebArchive - URL is not of type CFString, cannot create invalid resource");
         return 0;
     }
     
     CFStringRef textEncoding = static_cast<CFStringRef>(CFDictionaryGetValue(dictionary, LegacyWebArchiveResourceTextEncodingNameKey));
     if (textEncoding && CFGetTypeID(textEncoding) != CFStringGetTypeID()) {
-        LOG(Archives, "LegacyWebArchive - Text encoding is not of type CFString, cannot create invalid resource");
+        LOG_INFO(Archives, "LegacyWebArchive - Text encoding is not of type CFString, cannot create invalid resource");
         return 0;
     }
 
     ResourceResponse response;
     
     CFDataRef resourceResponseData = static_cast<CFDataRef>(CFDictionaryGetValue(dictionary, LegacyWebArchiveResourceResponseKey));
     if (resourceResponseData) {
         if (CFGetTypeID(resourceResponseData) != CFDataGetTypeID()) {
-            LOG(Archives, "LegacyWebArchive - Resource response data is not of type CFData, cannot create invalid resource");
+            LOG_INFO(Archives, "LegacyWebArchive - Resource response data is not of type CFData, cannot create invalid resource");
             return 0;
         }
         
         CFStringRef resourceResponseVersion = static_cast<CFStringRef>(CFDictionaryGetValue(dictionary, LegacyWebArchiveResourceResponseVersionKey));
         if (resourceResponseVersion && CFGetTypeID(resourceResponseVersion) != CFStringGetTypeID()) {
-            LOG(Archives, "LegacyWebArchive - Resource response version is not of type CFString, cannot create invalid resource");
+            LOG_INFO(Archives, "LegacyWebArchive - Resource response version is not of type CFString, cannot create invalid resource");
             return 0;
         }
         
         response = createResourceResponseFromPropertyListData(resourceResponseData, resourceResponseVersion);
     }
     
     return ArchiveResource::create(SharedBuffer::wrapCFData(resourceData), KURL(KURL(), url), mimeType, textEncoding, frameName, response);
 }
 
 PassRefPtr<LegacyWebArchive> LegacyWebArchive::create()
@@ skipping 19 matching lines @@
     return archive.release();
 }
 
 PassRefPtr<LegacyWebArchive> LegacyWebArchive::create(SharedBuffer* data)
 {
     return create(KURL(), data);
 }
 
 PassRefPtr<LegacyWebArchive> LegacyWebArchive::create(const KURL&, SharedBuffer* data)
 {
-    LOG(Archives, "LegacyWebArchive - Creating from raw data");
+    LOG_INFO(Archives, "LegacyWebArchive - Creating from raw data");
     
     RefPtr<LegacyWebArchive> archive = create();
         
     ASSERT(data);
     if (!data)
         return 0;
         
     RetainPtr<CFDataRef> cfData(AdoptCF, data->createCFData());
     if (!cfData)
         return 0;
         
     CFStringRef errorString = 0;
     
     RetainPtr<CFDictionaryRef> plist(AdoptCF, static_cast<CFDictionaryRef>(CFPropertyListCreateFromXMLData(0, cfData.get(), kCFPropertyListImmutable, &errorString)));
     if (!plist) {
 #ifndef NDEBUG
         const char* cError = errorString ? CFStringGetCStringPtr(errorString, kCFStringEncodingUTF8) : "unknown error";
-        LOG(Archives, "LegacyWebArchive - Error parsing PropertyList from archive data - %s", cError);
+        LOG_INFO(Archives, "LegacyWebArchive - Error parsing PropertyList from archive data - %s", cError);
 #endif
         if (errorString)
             CFRelease(errorString);
         return 0;
     }
     
     if (CFGetTypeID(plist.get()) != CFDictionaryGetTypeID()) {
-        LOG(Archives, "LegacyWebArchive - Archive property list is not the expected CFDictionary, aborting invalid WebArchive");
+        LOG_INFO(Archives, "LegacyWebArchive - Archive property list is not the expected CFDictionary, aborting invalid WebArchive");
         return 0;
     }
     
     if (!archive->extract(plist.get()))
         return 0;
 
     return archive.release();
 }
 
 bool LegacyWebArchive::extract(CFDictionaryRef dictionary)
 {
     ASSERT(dictionary);
     if (!dictionary) {
-        LOG(Archives, "LegacyWebArchive - Null root CFDictionary, aborting invalid WebArchive");
+        LOG_INFO(Archives, "LegacyWebArchive - Null root CFDictionary, aborting invalid WebArchive");
         return false;
     }
     
     CFDictionaryRef mainResourceDict = static_cast<CFDictionaryRef>(CFDictionaryGetValue(dictionary, LegacyWebArchiveMainResourceKey));
     if (!mainResourceDict) {
-        LOG(Archives, "LegacyWebArchive - No main resource in archive, aborting invalid WebArchive");
+        LOG_INFO(Archives, "LegacyWebArchive - No main resource in archive, aborting invalid WebArchive");
         return false;
     }
     if (CFGetTypeID(mainResourceDict) != CFDictionaryGetTypeID()) {
-        LOG(Archives, "LegacyWebArchive - Main resource is not the expected CFDictionary, aborting invalid WebArchive");
+        LOG_INFO(Archives, "LegacyWebArchive - Main resource is not the expected CFDictionary, aborting invalid WebArchive");
         return false;
     }
     
     setMainResource(createResource(mainResourceDict));
     if (!mainResource()) {
-        LOG(Archives, "LegacyWebArchive - Failed to parse main resource from CFDictionary or main resource does not exist, aborting invalid WebArchive");
+        LOG_INFO(Archives, "LegacyWebArchive - Failed to parse main resource from CFDictionary or main resource does not exist, aborting invalid WebArchive");
         return false;
     }
     
     if (mainResource()->mimeType().isNull()) {
-        LOG(Archives, "LegacyWebArchive - Main resource MIME type is required, but was null.");
+        LOG_INFO(Archives, "LegacyWebArchive - Main resource MIME type is required, but was null.");
         return false;
     }
     
     CFArrayRef subresourceArray = static_cast<CFArrayRef>(CFDictionaryGetValue(dictionary, LegacyWebArchiveSubresourcesKey));
     if (subresourceArray && CFGetTypeID(subresourceArray) != CFArrayGetTypeID()) {
-        LOG(Archives, "LegacyWebArchive - Subresources is not the expected Array, aborting invalid WebArchive");
+        LOG_INFO(Archives, "LegacyWebArchive - Subresources is not the expected Array, aborting invalid WebArchive");
         return false;
     }
     
     if (subresourceArray) {
         CFIndex count = CFArrayGetCount(subresourceArray);
         for (CFIndex i = 0; i < count; ++i) {
             CFDictionaryRef subresourceDict = static_cast<CFDictionaryRef>(CFArrayGetValueAtIndex(subresourceArray, i));
             if (CFGetTypeID(subresourceDict) != CFDictionaryGetTypeID()) {
-                LOG(Archives, "LegacyWebArchive - Subresource is not expected CFDictionary, aborting invalid WebArchive");
+                LOG_INFO(Archives, "LegacyWebArchive - Subresource is not expected CFDictionary, aborting invalid WebArchive");
                 return false;
             }
             
             if (RefPtr<ArchiveResource> subresource = createResource(subresourceDict))
                 addSubresource(subresource.release());
         }
     }
     
     CFArrayRef subframeArray = static_cast<CFArrayRef>(CFDictionaryGetValue(dictionary, LegacyWebArchiveSubframeArchivesKey));
     if (subframeArray && CFGetTypeID(subframeArray) != CFArrayGetTypeID()) {
-        LOG(Archives, "LegacyWebArchive - Subframe archives is not the expected Array, aborting invalid WebArchive");
+        LOG_INFO(Archives, "LegacyWebArchive - Subframe archives is not the expected Array, aborting invalid WebArchive");
         return false;
     }
     
     if (subframeArray) {
         CFIndex count = CFArrayGetCount(subframeArray);
         for (CFIndex i = 0; i < count; ++i) {
             CFDictionaryRef subframeDict = static_cast<CFDictionaryRef>(CFArrayGetValueAtIndex(subframeArray, i));
             if (CFGetTypeID(subframeDict) != CFDictionaryGetTypeID()) {
-                LOG(Archives, "LegacyWebArchive - Subframe array is not expected CFDictionary, aborting invalid WebArchive");
+                LOG_INFO(Archives, "LegacyWebArchive - Subframe array is not expected CFDictionary, aborting invalid WebArchive");
                 return false;
             }
             
             RefPtr<LegacyWebArchive> subframeArchive = create();
             if (subframeArchive->extract(subframeDict))
                 addSubframeArchive(subframeArchive.release());
             else
-                LOG(Archives, "LegacyWebArchive - Invalid subframe archive skipped");
+                LOG_INFO(Archives, "LegacyWebArchive - Invalid subframe archive skipped");
         }
     }
     
     return true;
 }
 
 Archive::Type LegacyWebArchive::type() const
 {
     return Archive::WebArchive;
 }
     
 RetainPtr<CFDataRef> LegacyWebArchive::rawDataRepresentation()
 {
     RetainPtr<CFDictionaryRef> propertyList = createPropertyListRepresentation(this);
     ASSERT(propertyList);
     if (!propertyList) {
-        LOG(Archives, "LegacyWebArchive - Failed to create property list for archive, returning no data");
+        LOG_INFO(Archives, "LegacyWebArchive - Failed to create property list for archive, returning no data");
         return 0;
     }
 
     RetainPtr<CFWriteStreamRef> stream(AdoptCF, CFWriteStreamCreateWithAllocatedBuffers(0, 0));
 
     CFWriteStreamOpen(stream.get());
     CFPropertyListWriteToStream(propertyList.get(), stream.get(), kCFPropertyListBinaryFormat_v1_0, 0);
 
     RetainPtr<CFDataRef> plistData(AdoptCF, static_cast<CFDataRef>(CFWriteStreamCopyProperty(stream.get(), kCFStreamPropertyDataWritten)));
     ASSERT(plistData);
 
     CFWriteStreamClose(stream.get());
 
     if (!plistData) {
-        LOG(Archives, "LegacyWebArchive - Failed to convert property list into raw data, returning no data");
+        LOG_INFO(Archives, "LegacyWebArchive - Failed to convert property list into raw data, returning no data");
         return 0;
     }
 
     return plistData;
 }
 
 #if !PLATFORM(MAC)
 
 ResourceResponse LegacyWebArchive::createResourceResponseFromMacArchivedData(CFDataRef responseData)
 {
@@ skipping 199 matching lines @@
 
     Vector<PassRefPtr<LegacyWebArchive> > subframeArchives;
     subframeArchives.append(archive);
     
     archive = create(iframeResource.release(), subresources, subframeArchives);
     
     return archive.release();
 }
 
 }