Revert 148069 and 148060 to see if they were responsible for a perf regression

Source/WebCore/loader/DocumentLoader.cpp

 /*
  * Copyright (C) 2006, 2007, 2008 Apple Inc. All rights reserved.
  * Copyright (C) 2011 Google 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. 
@@ skipping 36 matching lines @@
 #include "FrameTree.h"
 #include "HTMLFormElement.h"
 #include "HTMLFrameOwnerElement.h"
 #include "HistoryItem.h"
 #include "InspectorInstrumentation.h"
 #include "Logging.h"
 #include "MemoryCache.h"
 #include "Page.h"
 #include "ProgressTracker.h"
 #include "ResourceBuffer.h"
-#include "ResourceLoader.h"
 #include "SchemeRegistry.h"
 #include "SecurityPolicy.h"
 #include "Settings.h"
+#include "SubresourceLoader.h"
 #include "TextResourceDecoder.h"
 #include "WebCoreMemoryInstrumentation.h"
 #include <wtf/Assertions.h>
 #include <wtf/MemoryInstrumentationHashMap.h>
 #include <wtf/MemoryInstrumentationHashSet.h>
 #include <wtf/MemoryInstrumentationVector.h>
 #include <wtf/text/CString.h>
 #include <wtf/text/WTFString.h>
 #include <wtf/unicode/Unicode.h>
 
@@ skipping 177 matching lines @@
     if (m_committed) {
         // Attempt to stop the frame if the document loader is loading, or if it is done loading but
         // still  parsing. Failure to do so can cause a world leak.
         Document* doc = m_frame->document();
         
         if (loading || doc->parsing())
             m_frame->loader()->stopLoading(UnloadEventPolicyNone);
     }
 
     // Always cancel multipart loaders
-    cancelAll(m_multipartResourceLoaders);
+    cancelAll(m_multipartSubresourceLoaders);
 
     // Appcache uses ResourceHandle directly, DocumentLoader doesn't count these loads.
     m_applicationCacheHost->stopLoadingInFrame(m_frame);
     
     clearArchiveResources();
 
     if (!loading) {
         // If something above restarted loading we might run into mysterious crashes like 
         // https://bugs.webkit.org/show_bug.cgi?id=62764 and <rdar://problem/9328684>
         ASSERT(!isLoading());
         return;
     }
 
     // We might run in to infinite recursion if we're stopping loading as the result of 
     // detaching from the frame, so break out of that recursion here.
     // See <rdar://problem/9673866> for more details.
     if (m_isStopping)
         return;
 
     m_isStopping = true;
 
     FrameLoader* frameLoader = DocumentLoader::frameLoader();
     
     if (isLoadingMainResource())
         // Stop the main resource loader and let it send the cancelled message.
         cancelMainResourceLoad(frameLoader->cancelledError(m_request));
-    else if (!m_resourceLoaders.isEmpty())
+    else if (!m_subresourceLoaders.isEmpty())
         // The main resource loader already finished loading. Set the cancelled error on the 
-        // document and let the resourceLoaders send individual cancelled messages below.
+        // document and let the subresourceLoaders send individual cancelled messages below.
         setMainDocumentError(frameLoader->cancelledError(m_request));
     else
         // If there are no resource loaders, we need to manufacture a cancelled message.
         // (A back/forward navigation has no resource loaders because its resources are cached.)
         mainReceivedError(frameLoader->cancelledError(m_request));
     
     stopLoadingSubresources();
     
     m_isStopping = false;
 }
 
 void DocumentLoader::commitIfReady()
 {
     if (!m_committed) {
         m_committed = true;
         frameLoader()->commitProvisionalLoad();
     }
 }
 
 bool DocumentLoader::isLoading() const
 {
     // FIXME: This should always be enabled, but it seems to cause
     // http/tests/security/feed-urls-from-remote.html to timeout on Mac WK1
     // see http://webkit.org/b/110554 and http://webkit.org/b/110401
 #if ENABLE(THREADED_HTML_PARSER)
     if (document() && document()->hasActiveParser())
         return true;
 #endif
-    return isLoadingMainResource() || !m_resourceLoaders.isEmpty();
+    return isLoadingMainResource() || !m_subresourceLoaders.isEmpty();
 }
 
 void DocumentLoader::notifyFinished(CachedResource* resource)
 {
     ASSERT_UNUSED(resource, m_mainResource == resource);
     ASSERT(m_mainResource);
     if (!m_mainResource->errorOccurred() && !m_mainResource->wasCanceled()) {
         finishedLoading(m_mainResource->loadFinishTime());
         return;
     }
@@ skipping 384 matching lines @@
     ASSERT(m_frame->document()->parsing());
     m_writer.addData(bytes, length);
 }
 
 void DocumentLoader::reportMemoryUsage(MemoryObjectInfo* memoryObjectInfo) const
 {
     MemoryClassInfo info(memoryObjectInfo, this, WebCoreMemoryTypes::Loader);
     info.addMember(m_frame, "frame");
     info.addMember(m_cachedResourceLoader, "cachedResourceLoader");
     info.addMember(m_mainResource, "mainResource");
-    info.addMember(m_resourceLoaders, "resourceLoaders");
-    info.addMember(m_multipartResourceLoaders, "multipartResourceLoaders");
+    info.addMember(m_subresourceLoaders, "subresourceLoaders");
+    info.addMember(m_multipartSubresourceLoaders, "multipartSubresourceLoaders");
     info.addMember(m_substituteData, "substituteData");
     info.addMember(m_pageTitle.string(), "pageTitle.string()");
     info.addMember(m_overrideEncoding, "overrideEncoding");
     info.addMember(m_originalRequest, "originalRequest");
     info.addMember(m_originalRequestCopy, "originalRequestCopy");
     info.addMember(m_request, "request");
     info.addMember(m_response, "response");
     info.addMember(m_lastCheckedRequest, "lastCheckedRequest");
     info.addMember(m_pendingSubstituteResources, "pendingSubstituteResources");
     info.addMember(m_substituteResourceDeliveryTimer, "substituteResourceDeliveryTimer");
@@ skipping 183 matching lines @@
     copy.swap(m_pendingSubstituteResources);
 
     SubstituteResourceMap::const_iterator end = copy.end();
     for (SubstituteResourceMap::const_iterator it = copy.begin(); it != end; ++it) {
         RefPtr<ResourceLoader> loader = it->key;
         SubstituteResource* resource = it->value.get();
         
         if (resource) {
             SharedBuffer* data = resource->data();
         
-            loader->didReceiveResponse(0, resource->response());
+            loader->didReceiveResponse(resource->response());
 
             // Calling ResourceLoader::didReceiveResponse can end up cancelling the load,
             // so we need to check if the loader has reached its terminal state.
             if (loader->reachedTerminalState())
                 return;
 
             loader->didReceiveData(0, data->data(), data->size(), data->size());
 
             // Calling ResourceLoader::didReceiveData can end up cancelling the load,
             // so we need to check if the loader has reached its terminal state.
             if (loader->reachedTerminalState())
                 return;
 
-            loader->didFinishLoading(0, 0);
+            loader->didFinishLoading(0);
         } else {
             // A null resource means that we should fail the load.
             // FIXME: Maybe we should use another error here - something like "not in cache".
-            loader->didFail(0, loader->cannotShowURLError());
+            loader->didFail(loader->cannotShowURLError());
         }
     }
 }
 
 #ifndef NDEBUG
 bool DocumentLoader::isSubstituteLoadPending(ResourceLoader* loader) const
 {
     return m_pendingSubstituteResources.contains(loader);
 }
 #endif
@@ skipping 77 matching lines @@
 }
 
 void DocumentLoader::setDefersLoading(bool defers)
 {
     // Multiple frames may be loading the same main resource simultaneously. If deferral state changes,
     // each frame's DocumentLoader will try to send a setDefersLoading() to the same underlying ResourceLoader. Ensure only
     // the "owning" DocumentLoader does so, as setDefersLoading() is not resilient to setting the same value repeatedly.
     if (mainResourceLoader() && mainResourceLoader()->documentLoader() == this)
         mainResourceLoader()->setDefersLoading(defers);
 
-    setAllDefersLoading(m_resourceLoaders, defers);
+    setAllDefersLoading(m_subresourceLoaders, defers);
     if (!defers)
         deliverSubstituteResourcesAfterDelay();
 }
 
 void DocumentLoader::setMainResourceDataBufferingPolicy(DataBufferingPolicy dataBufferingPolicy)
 {
     if (m_mainResource)
         m_mainResource->setDataBufferingPolicy(dataBufferingPolicy);
 }
 
 void DocumentLoader::stopLoadingSubresources()
 {
-    cancelAll(m_resourceLoaders);
+    cancelAll(m_subresourceLoaders);
 }
 
-void DocumentLoader::addResourceLoader(ResourceLoader* loader)
+void DocumentLoader::addSubresourceLoader(ResourceLoader* loader)
 {
     // The main resource's underlying ResourceLoader will ask to be added here.
     // It is much simpler to handle special casing of main resource loads if we don't
     // let it be added. In the main resource load case, mainResourceLoader()
     // will still be null at this point, but m_gotFirstByte should be false here if and only
     // if we are just starting the main resource load.
     if (!m_gotFirstByte)
         return;
-    ASSERT(!m_resourceLoaders.contains(loader));
+    ASSERT(!m_subresourceLoaders.contains(loader));
     ASSERT(!mainResourceLoader() || mainResourceLoader() != loader);
-    m_resourceLoaders.add(loader);
+    m_subresourceLoaders.add(loader);
 }
 
-void DocumentLoader::removeResourceLoader(ResourceLoader* loader)
+void DocumentLoader::removeSubresourceLoader(ResourceLoader* loader)
 {
-    if (!m_resourceLoaders.contains(loader))
+    if (!m_subresourceLoaders.contains(loader))
         return;
-    m_resourceLoaders.remove(loader);
+    m_subresourceLoaders.remove(loader);
     checkLoadComplete();
     if (Frame* frame = m_frame)
         frame->loader()->checkLoadComplete();
 }
 
 bool DocumentLoader::isMultipartReplacingLoad() const
 {
     return isLoadingMultipartContent() && frameLoader()->isReplacing();
 }
 
@@ skipping 92 matching lines @@
     }
 
     if (mainResourceLoader())
         mainResourceLoader()->cancel(error);
 
     mainReceivedError(error);
 }
 
 void DocumentLoader::subresourceLoaderFinishedLoadingOnePart(ResourceLoader* loader)
 {
-    m_multipartResourceLoaders.add(loader);
-    m_resourceLoaders.remove(loader);
+    m_multipartSubresourceLoaders.add(loader);
+    m_subresourceLoaders.remove(loader);
     checkLoadComplete();
     if (Frame* frame = m_frame)
         frame->loader()->checkLoadComplete();    
 }
 
 void DocumentLoader::maybeFinishLoadingMultipartContent()
 {
     if (!isMultipartReplacingLoad())
         return;
 
     frameLoader()->setupForReplace();
     m_committed = false;
     RefPtr<ResourceBuffer> resourceData = mainResourceData();
     commitLoad(resourceData->data(), resourceData->size());
 }
 
 void DocumentLoader::handledOnloadEvents()
 {
     m_wasOnloadHandled = true;
     applicationCacheHost()->stopDeferringEvents();
 }
 
 } // namespace WebCore