Refactoring: Introduce ResouceLoaderHost interface for unloading ResourceLoader.

Source/core/loader/cache/CachedResourceLoader.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) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All rights reserved.
     Copyright (C) 2009 Torch Mobile Inc. http://www.torchmobile.com/
 
     This library is free software; you can redistribute it and/or
     modify it under the terms of the GNU Library General Public
     License as published by the Free Software Foundation; either
@@ skipping 13 matching lines @@
     pages from the web. It has a memory cache for these objects.
 */
 
 #include "config.h"
 #include "core/loader/cache/CachedResourceLoader.h"
 
 #include "bindings/v8/ScriptController.h"
 #include "core/dom/Document.h"
 #include "core/html/HTMLElement.h"
 #include "core/html/HTMLFrameOwnerElement.h"
+#include "core/inspector/InspectorInstrumentation.h"
 #include "core/loader/DocumentLoader.h"
 #include "core/loader/FrameLoader.h"
 #include "core/loader/FrameLoaderClient.h"
 #include "core/loader/PingLoader.h"
 #include "core/loader/UniqueIdentifier.h"
+#include "core/loader/appcache/ApplicationCacheHost.h"
 #include "core/loader/cache/CachedCSSStyleSheet.h"
 #include "core/loader/cache/CachedDocument.h"
 #include "core/loader/cache/CachedFont.h"
 #include "core/loader/cache/CachedImage.h"
 #include "core/loader/cache/CachedRawResource.h"
 #include "core/loader/cache/CachedResourceRequest.h"
 #include "core/loader/cache/CachedScript.h"
 #include "core/loader/cache/CachedShader.h"
 #include "core/loader/cache/CachedTextTrack.h"
 #include "core/loader/cache/CachedXSLStyleSheet.h"
@@ skipping 447 matching lines @@
         if (priority != resource->resourceRequest().priority()) {
             resource->resourceRequest().setPriority(priority);
             resource->didChangePriority(priority);
         }
     }
 
     if ((policy != Use || resource->stillNeedsLoad()) && CachedResourceRequest::NoDefer == request.defer()) {
         if (!frame())
             return 0;
 
-        FrameLoader* frameLoader = frame()->loader();
+        FrameLoader* frameLoader = this->frameLoader();
         if (request.options().securityCheck == DoSecurityCheck && (frameLoader->state() == FrameStateProvisional || !frameLoader->activeDocumentLoader() || frameLoader->activeDocumentLoader()->isStopping()))
             return 0;
 
         if (!m_documentLoader->scheduleArchiveLoad(resource.get(), request.resourceRequest()))
             resource->load(this, request.options());
 
         // We don't support immediate loads, but we do support immediate failure.
         if (resource->errorOccurred()) {
             if (resource->inCache())
                 memoryCache()->remove(resource.get());
@@ skipping 372 matching lines @@
         return CachePolicyVerify;
 
     if (type != CachedResource::MainResource)
         return frame()->loader()->subresourceCachePolicy();
     
     if (frame()->loader()->loadType() == FrameLoadTypeReloadFromOrigin || frame()->loader()->loadType() == FrameLoadTypeReload)
         return CachePolicyReload;
     return CachePolicyVerify;
 }
 
-void CachedResourceLoader::loadDone(CachedResource* resource)
+void CachedResourceLoader::didLoadResource(CachedResource* resource)
 {
     RefPtr<DocumentLoader> protectDocumentLoader(m_documentLoader);
     RefPtr<Document> protectDocument(m_document);
 
     if (resource && resource->response().isHTTP() && ((!resource->errorOccurred() && !resource->wasCanceled()) || resource->response().httpStatusCode() == 304)) {
         HashMap<CachedResource*, CachedResourceInitiatorInfo>::iterator initiatorIt = m_initiatorMap.find(resource);
         if (initiatorIt != m_initiatorMap.end()) {
             ASSERT(document());
             Document* initiatorDocument = document();
             if (resource->type() == CachedResource::MainResource)
@@ skipping 163 matching lines @@
             memoryCache()->remove(res);
     }
     m_preloads.clear();
 }
 
 void CachedResourceLoader::clearPendingPreloads()
 {
     m_pendingPreloads.clear();
 }
 
+inline FrameLoader* CachedResourceLoader::frameLoader()
+{
+    return frame() ? frame()->loader() : 0;
+}
+
+void CachedResourceLoader::didFinishLoading(const CachedResource* resource, double finishTime, const ResourceLoaderOptions& options)
+{
+    if (options.sendLoadCallbacks != SendCallbacks)
+        return;
+    if (FrameLoader* loader = frameLoader())
+        loader->notifier()->dispatchDidFinishLoading(m_documentLoader, resource->identifier(), finishTime);
+}
+
+void CachedResourceLoader::didChangeLoadingPriority(const CachedResource* resource, ResourceLoadPriority loadPriority)
+{
+    if (FrameLoader* loader = frameLoader())
+        loader->client()->dispatchDidChangeResourcePriority(resource->identifier(), loadPriority);
+}
+
+void CachedResourceLoader::didFailLoading(const CachedResource* resource, const ResourceError& error, const ResourceLoaderOptions& options)
+{
+    if (options.sendLoadCallbacks != SendCallbacks)
+        return;
+    if (FrameLoader* loader = frameLoader())
+        loader->notifier()->dispatchDidFail(m_documentLoader, resource->identifier(), error);
+}
+
+void CachedResourceLoader::willSendRequest(const CachedResource* resource, ResourceRequest& request, const ResourceResponse& redirectResponse, const ResourceLoaderOptions& options)
+{
+    if (options.sendLoadCallbacks == SendCallbacks) {
+        if (FrameLoader* loader = frameLoader())
+            loader->notifier()->dispatchWillSendRequest(m_documentLoader, resource->identifier(), request, redirectResponse, options.initiatorInfo);
+    } else {
+        InspectorInstrumentation::willSendRequest(frame(), resource->identifier(), m_documentLoader, request, redirectResponse, options.initiatorInfo);
+    }
+}
+
+void CachedResourceLoader::didReceiveResponse(const CachedResource* resource, const ResourceResponse& response, const ResourceLoaderOptions& options)
+{
+    if (options.sendLoadCallbacks != SendCallbacks)
+        return;
+    if (FrameLoader* loader = frameLoader())
+        loader->notifier()->dispatchDidReceiveResponse(m_documentLoader, resource->identifier(), response);
+}
+
+void CachedResourceLoader::didReceiveData(const CachedResource* resource, const char* data, int dataLength, int encodedDataLength, const ResourceLoaderOptions& options)
+{
+    if (options.sendLoadCallbacks != SendCallbacks)
+        return;
+    if (FrameLoader* loader = frameLoader())
+        loader->notifier()->dispatchDidReceiveData(m_documentLoader, resource->identifier(), data, dataLength, encodedDataLength);
+}
+
+ResourceError CachedResourceLoader::cancelledLoadingError(const ResourceRequest& request)
+{
+    if (FrameLoader* loader = frameLoader())
+        return loader->cancelledError(request);
+    return ResourceError(String(), 0, String(), String());
+}
+
+ResourceError CachedResourceLoader::cannotShowURLLoadingError(const ResourceRequest& request)
+{
+    if (FrameLoader* loader = frameLoader())
+        return loader->cancelledError(request);
+    return ResourceError(String(), 0, String(), String());
+}
+
+void CachedResourceLoader::subresourceLoaderFinishedLoadingOnePart(ResourceLoader* loader)
+{
+    if (m_documentLoader)
+        m_documentLoader->subresourceLoaderFinishedLoadingOnePart(loader);
+}
+
+void CachedResourceLoader::didInitializeResourceLoader(ResourceLoader* loader)
+{
+    if (m_documentLoader)
+        m_documentLoader->addResourceLoader(loader);
+}
+
+void CachedResourceLoader::willTerminateResourceLoader(ResourceLoader* loader)
+{
+    if (m_documentLoader)
+        m_documentLoader->removeResourceLoader(loader);
+}
+
+void CachedResourceLoader::willStartLoadingResource(ResourceRequest& request)
+{
+    if (m_documentLoader)
+        m_documentLoader->applicationCacheHost()->willStartLoadingResource(request);
+}
+
+bool CachedResourceLoader::defersLoading() const
+{
+    if (Frame* frame = this->frame())
+        return frame->page()->defersLoading();
+    return false;
+}
+
+bool CachedResourceLoader::isLoadedBy(CachedResourceLoader* possibleOwner) const
+{
+    return this == possibleOwner;
+}
+
+bool CachedResourceLoader::shouldRequest(CachedResource* resource, const ResourceRequest& request, const ResourceLoaderOptions& options)
+{
+    if (!canRequest(resource->type(), request.url(), options))
+        return false;
+    if (resource->type() == CachedResource::ImageResource && shouldDeferImageLoad(request.url()))
+        return false;
+    return true;
+}
+
+Frame* CachedResourceLoader::inspectedFrame() const
+{
+    // FIXME: return frame of master document for imported documents.
+    return m_documentLoader ? m_documentLoader->frame() : 0;
+}
+
+void CachedResourceLoader::refResourceLoaderHost()
+{
+    ref();
+}
+
+void CachedResourceLoader::derefResourceLoaderHost()
+{
+    deref();
+}
+
 #if PRELOAD_DEBUG
 void CachedResourceLoader::printPreloadStats()
 {
     unsigned scripts = 0;
     unsigned scriptMisses = 0;
     unsigned stylesheets = 0;
     unsigned stylesheetMisses = 0;
     unsigned images = 0;
     unsigned imageMisses = 0;
     ListHashSet<CachedResource*>::iterator end = m_preloads.end();
@@ skipping 48 matching lines @@
     info.addMember(m_garbageCollectDocumentResourcesTimer, "garbageCollectDocumentResourcesTimer");
 }
 
 const ResourceLoaderOptions& CachedResourceLoader::defaultCachedResourceOptions()
 {
     DEFINE_STATIC_LOCAL(ResourceLoaderOptions, options, (SendCallbacks, SniffContent, BufferData, AllowStoredCredentials, ClientRequestedCredentials, AskClientForCrossOriginCredentials, DoSecurityCheck, CheckContentSecurityPolicy, UseDefaultOriginRestrictionsForType, DocumentContext));
     return options;
 }
 
 }