For local review prior to sending to webkit

loader/FrameLoader.cpp

 /*
  * Copyright (C) 2006, 2007, 2008, 2009 Apple Inc. All rights reserved.
  * Copyright (C) 2008 Nokia Corporation and/or its subsidiary(-ies)
  * Copyright (C) 2008, 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.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
@@ skipping 80 matching lines @@
 #include "XMLHttpRequest.h"
 #include "XMLTokenizer.h"
 #include <wtf/CurrentTime.h>
 #include <wtf/StdLibExtras.h>
 
 #if ENABLE(OFFLINE_WEB_APPLICATIONS)
 #include "ApplicationCache.h"
 #include "ApplicationCacheResource.h"
 #endif
 
+#if ENABLE(APPLICATION_CACHE)
+#include "ApplicationCacheFrontend.h"
+#endif
+
 #if ENABLE(SVG)
 #include "SVGDocument.h"
 #include "SVGLocatable.h"
 #include "SVGNames.h"
 #include "SVGPreserveAspectRatio.h"
 #include "SVGSVGElement.h"
 #include "SVGViewElement.h"
 #include "SVGViewSpec.h"
 #endif
 
@@ skipping 184 matching lines @@
     , m_creatingInitialEmptyDocument(false)
     , m_isDisplayingInitialEmptyDocument(false)
     , m_committedFirstRealDocumentLoad(false)
     , m_didPerformFirstNavigation(false)
 #ifndef NDEBUG
     , m_didDispatchDidCommitLoad(false)
 #endif
 #if ENABLE(WML)
     , m_forceReloadWmlDeck(false)
 #endif
+#if ENABLE(APPLICATION_CACHE)
+    , m_appcacheFrontend(new ApplicationCacheFrontend())
+#endif
 {
 }
 
 FrameLoader::~FrameLoader()
 {
     setOpener(0);
 
     HashSet<Frame*>::iterator end = m_openedFrames.end();
     for (HashSet<Frame*>::iterator it = m_openedFrames.begin(); it != end; ++it)
         (*it)->loader()->m_opener = 0;
         
     m_client->frameLoaderDestroyed();
 }
 
 void FrameLoader::init()
 {
     // this somewhat odd set of steps is needed to give the frame an initial empty document
     m_isDisplayingInitialEmptyDocument = false;
     m_creatingInitialEmptyDocument = true;
     setPolicyDocumentLoader(m_client->createDocumentLoader(ResourceRequest(KURL("")), SubstituteData()).get());
     setProvisionalDocumentLoader(m_policyDocumentLoader.get());
     setState(FrameStateProvisional);
     m_provisionalDocumentLoader->setResponse(ResourceResponse(KURL(), "text/html", 0, String(), String()));
     m_provisionalDocumentLoader->finishedLoading();
     begin(KURL(), false);
     end();
     m_frame->document()->cancelParsing();
     m_creatingInitialEmptyDocument = false;
     m_didCallImplicitClose = true;
+
+#if ENABLE(APPLICATION_CACHE)
+    appcacheFrontend()->initializeForFrame(m_frame);
+#endif
 }
 
 void FrameLoader::setDefersLoading(bool defers)
 {
     if (m_documentLoader)
         m_documentLoader->setDefersLoading(defers);
     if (m_provisionalDocumentLoader)
         m_provisionalDocumentLoader->setDefersLoading(defers);
     if (m_policyDocumentLoader)
         m_policyDocumentLoader->setDefersLoading(defers);
@@ skipping 1493 matching lines @@
         && !m_quickRedirectComing
         && !m_documentLoader->isLoadingInAPISense()
         && !m_documentLoader->isStopping()
         && m_frame->document()->canSuspendActiveDOMObjects()
 #if ENABLE(OFFLINE_WEB_APPLICATIONS)
         // FIXME: We should investigating caching frames that have an associated
         // application cache. <rdar://problem/5917899> tracks that work.
         && !m_documentLoader->applicationCache()
         && !m_documentLoader->candidateApplicationCacheGroup()
 #endif
+#if ENABLE(APPLICATION_CACHE)
+        // FIXME: We should investigating caching frames that have an associated
+        // application cache. <rdar://problem/5917899> tracks that work.
+        && appcacheFrontend()->canCacheCurrentDocumentInPageCache()
+#endif
         && m_client->canCachePage()
         ;
 }
 
 bool FrameLoader::canCachePage()
 {
 #ifndef NDEBUG
     logCanCachePageDecision();
 #endif
     
@@ skipping 130 matching lines @@
         if (m_documentLoader->isStopping())
             { PCLOG("   -DocumentLoader is in the middle of stopping"); cannotCache = true; }
         if (!m_frame->document()->canSuspendActiveDOMObjects())
             { PCLOG("   -The document cannot suspect its active DOM Objects"); cannotCache = true; }
 #if ENABLE(OFFLINE_WEB_APPLICATIONS)
         if (m_documentLoader->applicationCache())
             { PCLOG("   -The DocumentLoader has an active application cache"); cannotCache = true; }
         if (m_documentLoader->candidateApplicationCacheGroup())
             { PCLOG("   -The DocumentLoader has a candidateApplicationCacheGroup"); cannotCache = true; }
 #endif
+#if ENABLE(APPLICATION_CACHE)
+        if (!appcacheFrontend()->canCacheCurrentDocumentInPageCache())
+            { PCLOG("   -Using application cache"); cannotCache = true; }
+#endif
         if (!m_client->canCachePage())
             { PCLOG("   -The client says this frame cannot be cached"); cannotCache = true; }
     } while (false);
 
     for (Frame* child = m_frame->tree()->firstChild(); child; child = child->tree()->nextSibling())
         if (!child->loader()->logCanCacheFrameDecision(indentLevel + 1))
             cannotCache = true;
     
     PCLOG(cannotCache ? " Frame CANNOT be cached" : " Frame CAN be cached");
     PCLOG("+---");
@@ skipping 874 matching lines @@
         return;
 
     // Nothing else can interupt this commit - set the Provisional->Committed transition in stone
     if (m_documentLoader)
         m_documentLoader->stopLoadingSubresources();
     if (m_documentLoader)
         m_documentLoader->stopLoadingPlugIns();
 
     setDocumentLoader(m_provisionalDocumentLoader.get());
     setProvisionalDocumentLoader(0);
+#if ENABLE(APPLICATION_CACHE)
+    selectInitialApplicationCache();
+#endif
     setState(FrameStateCommittedPage);
 
     // Handle adding the URL to the back/forward list.
     DocumentLoader* dl = m_documentLoader.get();
     String ptitle = dl->title(); 
 
     switch (m_loadType) {
         case FrameLoadTypeForward:
         case FrameLoadTypeBack:
         case FrameLoadTypeIndexedBackForward:
@@ skipping 665 matching lines @@
 void FrameLoader::addExtraFieldsToRequest(ResourceRequest& request, FrameLoadType loadType, bool mainResource, bool cookiePolicyURLFromRequest)
 {
     // Don't set the cookie policy URL if it's already been set.
     // But make sure to set it on all requests, as it has significance beyond the cookie policy for all protocols (<rdar://problem/6616664>).
     if (request.firstPartyForCookies().isEmpty()) {
         if (mainResource && (isLoadingMainFrame() || cookiePolicyURLFromRequest))
             request.setFirstPartyForCookies(request.url());
         else if (Document* document = m_frame->document())
             request.setFirstPartyForCookies(document->firstPartyForCookies());
     }
+ 
+#if ENABLE(APPLICATION_CACHE)
+    appcacheFrontend()->addExtraFieldsToRequest(request, mainResource);
+#endif
 
     // The remaining modifications are only necessary for HTTP and HTTPS.
     if (!request.url().isEmpty() && !request.url().protocolInHTTPFamily())
         return;
 
     applyUserAgent(request);
     
     if (loadType == FrameLoadTypeReload) {
         request.setCachePolicy(ReloadIgnoringCacheData);
         request.setHTTPHeaderField("Cache-Control", "max-age=0");
@@ skipping 1688 matching lines @@
         ResourceRequest request(resource->url());
         m_client->dispatchDidLoadResourceFromMemoryCache(m_documentLoader.get(), request, resource->response(), resource->encodedSize());
     }
 }
 
 bool FrameLoaderClient::hasHTMLView() const
 {
     return true;
 }
 
+#if ENABLE(APPLICATION_CACHE)
+
+ApplicationCacheFrontend* FrameLoader::appcacheFrontend() const
+{
+    return m_appcacheFrontend.get();
+}
+
+void FrameLoader::selectInitialApplicationCache()
+{
+    const KURL& docURL = m_frame->document()->url();
+    const ResourceResponse& docResponse = documentLoader()->response();
+    appcacheFrontend()->selectInitialCache(docURL,
+                                           docResponse.applicationCacheID());
+}
+
+void FrameLoader::selectApplicationCacheWithoutManifest()
+{
+    const KURL& docURL = m_frame->document()->url();
+    const ResourceResponse& docResponse = documentLoader()->response();
+    appcacheFrontend()->selectCacheWithoutManifest(
+                                         docURL,
+                                         docResponse.applicationCacheID());
+}
+
+void FrameLoader::selectApplicationCacheWithManifest(const KURL& manifestURL)
+{
+    const KURL& docURL = m_frame->document()->url();
+    const ResourceResponse& docResponse = documentLoader()->response();
+    if (!appcacheFrontend()->selectCacheWithManifest(
+                                         docURL,
+                                         docResponse.applicationCacheID(),
+                                         docResponse.manifestURL(),
+                                         manifestURL)) {
+        // It's a foreign entry, restart the current navigation from the top of the navigation algorithm.
+        // The navigation will not result in the same resource being loaded, because "foreign" entries are
+        // never picked during navigation.
+        scheduleLocationChange(docURL, referrer(), true);
+    }
+}
+#endif
+
 } // namespace WebCore