Remove a bunch of ApplicationCacheHost functions and parameters we don't use.

Source/core/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 191 matching lines @@
 
 void DocumentLoader::setMainDocumentError(const ResourceError& error)
 {
     m_mainDocumentError = error;    
     frameLoader()->client()->setMainDocumentError(this, error);
 }
 
 void DocumentLoader::mainReceivedError(const ResourceError& error)
 {
     ASSERT(!error.isNull());
-    if (m_applicationCacheHost->maybeLoadFallbackForMainError(request(), error))
-        return;
-
     if (m_identifierForLoadWithoutResourceLoader) {
         ASSERT(!mainResourceLoader());
         frameLoader()->client()->dispatchDidFailLoading(this, m_identifierForLoadWithoutResourceLoader, error);
     }
 
     ASSERT(!mainResourceLoader() || !mainResourceLoader()->defersLoading());
 
     m_applicationCacheHost->failedLoadingMainResource();
 
     if (!frameLoader())
@@ skipping 21 matching lines @@
         // 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);
-
-    // 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;
     }
 
@@ skipping 219 matching lines @@
             cancelMainResourceLoad(frameLoader()->cancelledError(newRequest));
             return;
         }
     }
 
     setRequest(newRequest);
 
     if (redirectResponse.isNull())
         return;
 
-    // We checked application cache for initial URL, now we need to check it for redirected one.
-    ASSERT(!m_substituteData.isValid());
-    m_applicationCacheHost->maybeLoadMainResourceForRedirect(newRequest, m_substituteData);
-    if (m_substituteData.isValid())
-        m_identifierForLoadWithoutResourceLoader = mainResourceLoader()->identifier();
-
-    if (!shouldContinueForNavigationPolicy(newRequest)) {
+    if (!shouldContinueForNavigationPolicy(newRequest))
         stopLoadingForPolicyChange();
-        return;
-    }
-
-    if (!m_substituteData.isValid())
-        return;
-    // A redirect resulted in loading substitute data.
-    ASSERT(timing()->redirectCount());
-
-    // We need to remove our reference to the CachedResource in favor of a SubstituteData load.
-    // This will probably trigger the cancellation of the CachedResource's underlying ResourceLoader, though there is a
-    // small chance that the resource is being loaded by a different Frame, preventing the ResourceLoader from being cancelled.
-    // If the ResourceLoader is indeed cancelled, it would normally send resource load callbacks.
-    // However, from an API perspective, this isn't a cancellation. Therefore, sever our relationship with the network load,
-    // but prevent the ResourceLoader from sending ResourceLoadNotifier callbacks.
-    RefPtr<ResourceLoader> resourceLoader = mainResourceLoader();
-    ASSERT(resourceLoader->shouldSendResourceLoadCallbacks());
-    resourceLoader->setSendCallbackPolicy(DoNotSendCallbacks);
-    if (m_mainResource) {
-        m_mainResource->removeClient(this);
-        m_mainResource = 0;
-    }
-    resourceLoader->setSendCallbackPolicy(SendCallbacks);
-    handleSubstituteDataLoadSoon();
 }
 
 bool DocumentLoader::shouldContinueForResponse() const
 {
     if (m_substituteData.isValid())
         return true;
 
     int statusCode = m_response.httpStatusCode();
     if (statusCode == 204 || statusCode == 205) {
         // The server does not want us to replace the page contents.
@@ skipping 15 matching lines @@
         return false;
 
     return true;
 }
 
 void DocumentLoader::responseReceived(CachedResource* resource, const ResourceResponse& response)
 {
     ASSERT_UNUSED(resource, m_mainResource == resource);
     RefPtr<DocumentLoader> protect(this);
 
-    m_applicationCacheHost->maybeLoadFallbackForMainResponse(request(), response);
+    m_applicationCacheHost->didReceiveResponseForMainResource(response);
 
     // The memory cache doesn't understand the application cache or its caching rules. So if a main resource is served
     // from the application cache, ensure we don't save the result for future use. All responses loaded
     // from appcache will have a non-zero appCacheID().
     if (response.appCacheID())
         memoryCache()->remove(m_mainResource.get());
 
     DEFINE_STATIC_LOCAL(AtomicString, xFrameOptionHeader, ("x-frame-options", AtomicString::ConstructFromLiteral));
     HTTPHeaderMap::const_iterator it = response.httpHeaderFields().find(xFrameOptionHeader);
     if (it != response.httpHeaderFields().end()) {
@@ skipping 157 matching lines @@
 {
     ASSERT(data);
     ASSERT(length);
     ASSERT_UNUSED(resource, resource == m_mainResource);
     ASSERT(!m_response.isNull());
     ASSERT(!mainResourceLoader() || !mainResourceLoader()->defersLoading());
 
     if (m_identifierForLoadWithoutResourceLoader)
         frameLoader()->notifier()->dispatchDidReceiveData(this, m_identifierForLoadWithoutResourceLoader, data, length, -1);
 
-    m_applicationCacheHost->mainResourceDataReceived(data, length, -1, false);
+    m_applicationCacheHost->mainResourceDataReceived(data, length);
     m_timeOfLastDataReceived = monotonicallyIncreasingTime();
 
     if (!isMultipartReplacingLoad())
         commitLoad(data, length);
 }
 
 void DocumentLoader::setupForReplace()
 {
     if (!mainResourceData())
         return;
@@ skipping 333 matching lines @@
 
     ASSERT(timing()->navigationStart());
     ASSERT(!timing()->fetchStart());
     timing()->markFetchStart();
     willSendRequest(m_request, ResourceResponse());
 
     // willSendRequest() may lead to our Frame being detached or cancelling the load via nulling the ResourceRequest.
     if (!m_frame || m_request.isNull())
         return;
 
-    m_applicationCacheHost->maybeLoadMainResource(m_request, m_substituteData);
+    m_applicationCacheHost->willStartLoadingMainResource(m_request);
 
     if (m_substituteData.isValid()) {
         m_identifierForLoadWithoutResourceLoader = createUniqueIdentifier();
         frameLoader()->notifier()->dispatchWillSendRequest(this, m_identifierForLoadWithoutResourceLoader, m_request, ResourceResponse());
         handleSubstituteDataLoadSoon();
         return;
     }
 
     ResourceRequest request(m_request);
     DEFINE_STATIC_LOCAL(ResourceLoaderOptions, mainResourceLoadOptions,
@@ skipping 58 matching lines @@
     commitLoad(resourceData->data(), resourceData->size());
 }
 
 void DocumentLoader::handledOnloadEvents()
 {
     m_wasOnloadHandled = true;
     applicationCacheHost()->stopDeferringEvents();
 }
 
 } // namespace WebCore