Refactoring: Introduce ResouceLoaderHost interface for unloading ResourceLoader.

Source/core/loader/ResourceLoader.cpp

 /*
  * Copyright (C) 2006, 2007, 2010, 2011 Apple Inc. All rights reserved.
  *           (C) 2007 Graham Dennis (graham.dennis@gmail.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. 
@@ skipping 13 matching lines @@
  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
 #include "core/loader/ResourceLoader.h"
 
 #include "core/inspector/InspectorInstrumentation.h"
-#include "core/loader/DocumentLoader.h"
-#include "core/loader/FrameLoader.h"
-#include "core/loader/FrameLoaderClient.h"
-#include "core/loader/appcache/ApplicationCacheHost.h"
-#include "core/loader/cache/CachedResourceLoader.h"
-#include "core/page/Frame.h"
+#include "core/loader/ResourceLoaderHost.h"
 #include "core/page/Page.h"
 #include "core/platform/Logging.h"
 #include "core/platform/network/ResourceError.h"
 #include "core/platform/network/ResourceHandle.h"
 
 namespace WebCore {
 
-ResourceLoader::RequestCountTracker::RequestCountTracker(CachedResourceLoader* cachedResourceLoader, CachedResource* resource)
-    : m_cachedResourceLoader(cachedResourceLoader)
+ResourceLoader::RequestCountTracker::RequestCountTracker(ResourceLoaderHost* host, CachedResource* resource)
+    : m_host(host)
     , m_resource(resource)
 {
-    m_cachedResourceLoader->incrementRequestCount(m_resource);
+    m_host->incrementRequestCount(m_resource);
 }
 
 ResourceLoader::RequestCountTracker::~RequestCountTracker()
 {
-    m_cachedResourceLoader->decrementRequestCount(m_resource);
+    m_host->decrementRequestCount(m_resource);
 }
 
-PassRefPtr<ResourceLoader> ResourceLoader::create(DocumentLoader* documentLoader, CachedResource* resource, const ResourceRequest& request, const ResourceLoaderOptions& options)
+PassRefPtr<ResourceLoader> ResourceLoader::create(ResourceLoaderHost* host, CachedResource* resource, const ResourceRequest& request, const ResourceLoaderOptions& options)
 {
-    RefPtr<ResourceLoader> loader(adoptRef(new ResourceLoader(documentLoader, resource, options)));
+    RefPtr<ResourceLoader> loader(adoptRef(new ResourceLoader(host, resource, options)));
     if (!loader->init(request))
         return 0;
     loader->start();
     return loader.release();
 }
 
-ResourceLoader::ResourceLoader(DocumentLoader* documentLoader, CachedResource* resource, ResourceLoaderOptions options)
-    : m_frame(documentLoader->frame())
-    , m_documentLoader(documentLoader)
+ResourceLoader::ResourceLoader(ResourceLoaderHost* host, CachedResource* resource, const ResourceLoaderOptions& options)
+    : m_host(host)
     , m_loadingMultipartContent(false)
     , m_notifiedLoadComplete(false)
-    , m_defersLoading(m_frame->page()->defersLoading())
+    , m_defersLoading(host->defersLoading())
     , m_options(options)
     , m_resource(resource)
     , m_state(Uninitialized)
-    , m_requestCountTracker(adoptPtr(new RequestCountTracker(documentLoader->cachedResourceLoader(), resource)))
+    , m_requestCountTracker(adoptPtr(new RequestCountTracker(host, resource)))
 {
 }
 
 ResourceLoader::~ResourceLoader()
 {
     ASSERT(m_state == Terminated);
 }
 
 void ResourceLoader::releaseResources()
 {
     ASSERT(m_state != Terminated);
     if (m_state != Uninitialized) {
         m_requestCountTracker.clear();
-        m_documentLoader->cachedResourceLoader()->loadDone(m_resource);
+        m_host->didLoadResource(m_resource);
         if (m_state == Terminated)
             return;
         m_resource->clearLoader();
-        m_documentLoader->removeResourceLoader(this);
+        m_host->willTerminateResourceLoader(this);
     }
 
     ASSERT(m_state != Terminated);
     
     // It's possible that when we release the handle, it will be
     // deallocated and release the last reference to this object.
     // We need to retain to avoid accessing the object after it
     // has been deallocated and also to avoid reentering this method.
     RefPtr<ResourceLoader> protector(this);
 
-    m_frame = 0;
-    m_documentLoader = 0;
-
+    m_host.clear();
     m_state = Terminated;
 
     if (m_handle) {
         // Clear out the ResourceHandle's client so that it doesn't try to call
         // us back after we release it, unless it has been replaced by someone else.
         if (m_handle->client() == this)
             m_handle->setClient(0);
         m_handle = 0;
     }
 
@@ skipping 10 matching lines @@
 
     willSendRequest(0, clientRequest, ResourceResponse());
     if (clientRequest.isNull()) {
         cancel();
         return false;
     }
     ASSERT(m_state != Terminated);
 
     m_originalRequest = m_request = clientRequest;
     m_state = Initialized;
-    m_documentLoader->addResourceLoader(this);
+    m_host->didInitializeResourceLoader(this);
     return true;
 }
 
 void ResourceLoader::start()
 {
     ASSERT(!m_handle);
     ASSERT(!m_request.isNull());
     ASSERT(m_deferredRequest.isNull());
 
-    m_documentLoader->applicationCacheHost()->willStartLoadingResource(m_request);
+    m_host->willStartLoadingResource(m_request);
 
     if (m_defersLoading) {
         m_deferredRequest = m_request;
         return;
     }
 
     if (m_state != Terminated)
         m_handle = ResourceHandle::create(m_request, this, m_defersLoading, m_options.sniffContent == SniffContent, m_options.allowCredentials);
 }
 
 void ResourceLoader::setDefersLoading(bool defers)
 {
     m_defersLoading = defers;
     if (m_handle)
         m_handle->setDefersLoading(defers);
     if (!defers && !m_deferredRequest.isNull()) {
         m_request = m_deferredRequest;
         m_deferredRequest = ResourceRequest();
         start();
     }
 }
 
-FrameLoader* ResourceLoader::frameLoader() const
-{
-    if (!m_frame)
-        return 0;
-    return m_frame->loader();
-}
-
 void ResourceLoader::didDownloadData(ResourceHandle*, int length)
 {
     RefPtr<ResourceLoader> protect(this);
     m_resource->didDownloadData(length);
 }
 
 void ResourceLoader::didFinishLoadingOnePart(double finishTime)
 {
     // If load has been cancelled after finishing (which could happen with a
     // JavaScript that changes the window location), do nothing.
     if (m_state == Terminated)
         return;
 
     if (m_notifiedLoadComplete)
         return;
     m_notifiedLoadComplete = true;
-    if (m_options.sendLoadCallbacks == SendCallbacks)
-        frameLoader()->notifier()->dispatchDidFinishLoading(m_documentLoader.get(), m_resource->identifier(), finishTime);
+    m_host->didFinishLoading(m_resource, finishTime, m_options);
 }
 
 void ResourceLoader::didChangePriority(ResourceLoadPriority loadPriority)
 {
     if (handle()) {
-        frameLoader()->client()->dispatchDidChangeResourcePriority(m_resource->identifier(), loadPriority);
+        m_host->didChangeLoadingPriority(m_resource, loadPriority);
         handle()->didChangePriority(loadPriority);
     }
 }
 
 void ResourceLoader::cancelIfNotFinishing()
 {
     if (m_state != Initialized)
         return;
     cancel();
 }
@@ skipping 22 matching lines @@
     LOG(ResourceLoading, "Cancelled load of '%s'.\n", m_resource->url().string().latin1().data());
     if (m_state == Initialized)
         m_state = Finishing;
     m_resource->setResourceError(nonNullError);
 
     if (m_handle) {
         m_handle->cancel();
         m_handle = 0;
     }
 
-    if (m_options.sendLoadCallbacks == SendCallbacks && !m_notifiedLoadComplete)
-        frameLoader()->notifier()->dispatchDidFail(m_documentLoader.get(), m_resource->identifier(), nonNullError);
+    m_host->didFailLoading(m_resource, nonNullError, m_options);
 
     if (m_state == Finishing)
         m_resource->error(CachedResource::LoadError);
     if (m_state != Terminated)
         releaseResources();
 }
 
 void ResourceLoader::willSendRequest(ResourceHandle*, ResourceRequest& request, const ResourceResponse& redirectResponse)
 {
     // Store the previous URL because we may modify it.
     KURL previousURL = m_request.url();
     RefPtr<ResourceLoader> protect(this);
 
     ASSERT(!request.isNull());
     if (!redirectResponse.isNull()) {
-        if (!m_documentLoader->cachedResourceLoader()->canRequest(m_resource->type(), request.url(), m_options)) {
+        if (!m_host->shouldRequest(m_resource, request, m_options)) {
             cancel();
             return;
         }
-        if (m_resource->type() == CachedResource::ImageResource && m_documentLoader->cachedResourceLoader()->shouldDeferImageLoad(request.url())) {
-            cancel();
-            return;
-        }
+
         m_resource->willSendRequest(request, redirectResponse);
     }
 
     if (request.isNull() || m_state == Terminated)
         return;
 
-    if (m_options.sendLoadCallbacks == SendCallbacks)
-        frameLoader()->notifier()->dispatchWillSendRequest(m_documentLoader.get(), m_resource->identifier(), request, redirectResponse, m_options.initiatorInfo);
-    else
-        InspectorInstrumentation::willSendRequest(m_frame.get(), m_resource->identifier(), m_documentLoader.get(), request, redirectResponse, m_options.initiatorInfo);
-
+    m_host->willSendRequest(m_resource, request, redirectResponse, m_options);
     m_request = request;
 
     if (request.isNull())
         cancel();
 }
 
 void ResourceLoader::didReceiveCachedMetadata(ResourceHandle*, const char* data, int length)
 {
     ASSERT(m_state == Initialized);
     m_resource->setSerializedCachedMetadata(data, length);
@@ skipping 11 matching lines @@
     ASSERT(!response.isNull());
     ASSERT(m_state == Initialized);
 
     // Reference the object in this method since the additional processing can do
     // anything including removing the last reference to this object.
     RefPtr<ResourceLoader> protect(this);
     m_resource->responseReceived(response);
     if (m_state == Terminated)
         return;
 
-    if (m_options.sendLoadCallbacks == SendCallbacks)
-        frameLoader()->notifier()->dispatchDidReceiveResponse(m_documentLoader.get(), m_resource->identifier(), response);
+    m_host->didReceiveResponse(m_resource, response, m_options);
 
     if (response.isMultipart()) {
         m_loadingMultipartContent = true;
 
         // We don't count multiParts in a CachedResourceLoader's request count
         m_requestCountTracker.clear();
         if (!m_resource->isImage()) {
             cancel();
             return;
         }
     } else if (m_loadingMultipartContent) {
         // Since a subresource loader does not load multipart sections progressively, data was delivered to the loader all at once.
         // After the first multipart section is complete, signal to delegates that this load is "finished"
-        m_documentLoader->subresourceLoaderFinishedLoadingOnePart(this);
+        m_host->subresourceLoaderFinishedLoadingOnePart(this);
         didFinishLoadingOnePart(0);
     }
 
     if (m_resource->response().httpStatusCode() < 400 || m_resource->shouldIgnoreHTTPStatusCodeErrors())
         return;
     m_state = Finishing;
     m_resource->error(CachedResource::LoadError);
     cancel();
 }
 
 void ResourceLoader::didReceiveData(ResourceHandle*, const char* data, int length, int encodedDataLength)
 {
     // It is possible to receive data on uninitialized resources if it had an error status code, and we are running a nested message
     // loop. When this occurs, ignoring the data is the correct action.
     if (m_resource->response().httpStatusCode() >= 400 && !m_resource->shouldIgnoreHTTPStatusCodeErrors())
         return;
-    InspectorInstrumentationCookie cookie = InspectorInstrumentation::willReceiveResourceData(m_frame.get(), m_resource->identifier(), encodedDataLength);
+    InspectorInstrumentationCookie cookie = InspectorInstrumentation::willReceiveResourceData(m_host->inspectedFrame(), m_resource->identifier(), encodedDataLength);
     ASSERT(m_state == Initialized);
 
     // Reference the object in this method since the additional processing can do
     // anything including removing the last reference to this object.
     RefPtr<ResourceLoader> protect(this);
 
     // FIXME: If we get a resource with more than 2B bytes, this code won't do the right thing.
     // However, with today's computers and networking speeds, this won't happen in practice.
     // Could be an issue with a giant local file.
-    if (m_options.sendLoadCallbacks == SendCallbacks && m_frame)
-        frameLoader()->notifier()->dispatchDidReceiveData(m_documentLoader.get(), m_resource->identifier(), data, length, static_cast<int>(encodedDataLength));
-
+    m_host->didReceiveData(m_resource, data, length, encodedDataLength, m_options);
     m_resource->appendData(data, length);
 
     InspectorInstrumentation::didReceiveResourceData(cookie);
 }
 
 void ResourceLoader::didFinishLoading(ResourceHandle*, double finishTime)
 {
     if (m_state != Initialized)
         return;
     ASSERT(m_state != Terminated);
@@ skipping 11 matching lines @@
         return;
     releaseResources();
 }
 
 void ResourceLoader::didFail(ResourceHandle*, const ResourceError& error)
 {
     ASSERT(m_state != Terminated);
     LOG(ResourceLoading, "Failed to load '%s'.\n", m_resource->url().string().latin1().data());
 
     RefPtr<ResourceLoader> protect(this);
+    RefPtr<ResourceLoaderHost> protectHost(m_host);
     CachedResourceHandle<CachedResource> protectResource(m_resource);
     m_state = Finishing;
     m_resource->setResourceError(error);
     m_resource->error(CachedResource::LoadError);
 
     if (m_state == Terminated)
         return;
 
     if (!m_notifiedLoadComplete) {
         m_notifiedLoadComplete = true;
-        if (m_options.sendLoadCallbacks == SendCallbacks)
-            frameLoader()->notifier()->dispatchDidFail(m_documentLoader.get(), m_resource->identifier(), error);
+        m_host->didFailLoading(m_resource, error, m_options);
     }
 
     releaseResources();
 }
 
+bool ResourceLoader::isLoadedBy(ResourceLoaderHost* loader) const
+{
+    return m_host->isLoadedBy(loader);
 }
+
+}