Home | History | Annotate | Download | only in appcache 
      1 /*
      2  * Copyright (C) 2008, 2009 Apple Inc. All Rights Reserved.
      3  *
      4  * Redistribution and use in source and binary forms, with or without
      5  * modification, are permitted provided that the following conditions
      6  * are met:
      7  * 1. Redistributions of source code must retain the above copyright
      8  *    notice, this list of conditions and the following disclaimer.
      9  * 2. Redistributions in binary form must reproduce the above copyright
     10  *    notice, this list of conditions and the following disclaimer in the
     11  *    documentation and/or other materials provided with the distribution.
     12  *
     13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
     14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
     16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
     17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
     18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
     19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
     20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
     21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
     22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
     23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     24  */
     25 
     26 #include "config.h"
     27 #include "ApplicationCacheHost.h"
     28 
     29 #if ENABLE(OFFLINE_WEB_APPLICATIONS)
     30 
     31 #include "ApplicationCache.h"
     32 #include "ApplicationCacheGroup.h"
     33 #include "ApplicationCacheResource.h"
     34 #include "DocumentLoader.h"
     35 #include "DOMApplicationCache.h"
     36 #include "Frame.h"
     37 #include "FrameLoader.h"
     38 #include "FrameLoaderClient.h"
     39 #include "MainResourceLoader.h"
     40 #include "ResourceLoader.h"
     41 #include "ResourceRequest.h"
     42 #include "Settings.h"
     43 
     44 namespace WebCore {
     45 
     46 ApplicationCacheHost::ApplicationCacheHost(DocumentLoader* documentLoader)
     47     : m_domApplicationCache(0)
     48     , m_documentLoader(documentLoader)
     49     , m_defersEvents(true)
     50     , m_candidateApplicationCacheGroup(0)
     51 {
     52     ASSERT(m_documentLoader);
     53 }
     54 
     55 ApplicationCacheHost::~ApplicationCacheHost()
     56 {
     57     if (m_applicationCache)
     58         m_applicationCache->group()->disassociateDocumentLoader(m_documentLoader);
     59     else if (m_candidateApplicationCacheGroup)
     60         m_candidateApplicationCacheGroup->disassociateDocumentLoader(m_documentLoader);
     61 }
     62 
     63 void ApplicationCacheHost::selectCacheWithoutManifest()
     64 {
     65     ApplicationCacheGroup::selectCacheWithoutManifestURL(m_documentLoader->frame());
     66 }
     67 
     68 void ApplicationCacheHost::selectCacheWithManifest(const KURL& manifestURL)
     69 {
     70     ApplicationCacheGroup::selectCache(m_documentLoader->frame(), manifestURL);
     71 }
     72 
     73 void ApplicationCacheHost::maybeLoadMainResource(ResourceRequest& request, SubstituteData& substituteData)
     74 {
     75     // Check if this request should be loaded from the application cache
     76     if (!substituteData.isValid() && isApplicationCacheEnabled()) {
     77         ASSERT(!m_mainResourceApplicationCache);
     78 
     79         m_mainResourceApplicationCache = ApplicationCacheGroup::cacheForMainRequest(request, m_documentLoader);
     80 
     81         if (m_mainResourceApplicationCache) {
     82             // Get the resource from the application cache. By definition, cacheForMainRequest() returns a cache that contains the resource.
     83             ApplicationCacheResource* resource = m_mainResourceApplicationCache->resourceForRequest(request);
     84             substituteData = SubstituteData(resource->data(),
     85                                             resource->response().mimeType(),
     86                                             resource->response().textEncodingName(), KURL());
     87         }
     88     }
     89 }
     90 
     91 bool ApplicationCacheHost::maybeLoadFallbackForMainResponse(const ResourceRequest& request, const ResourceResponse& r)
     92 {
     93     if (r.httpStatusCode() / 100 == 4 || r.httpStatusCode() / 100 == 5) {
     94         ASSERT(!m_mainResourceApplicationCache);
     95         if (isApplicationCacheEnabled()) {
     96             m_mainResourceApplicationCache = ApplicationCacheGroup::fallbackCacheForMainRequest(request, documentLoader());
     97 
     98             if (scheduleLoadFallbackResourceFromApplicationCache(documentLoader()->mainResourceLoader(), m_mainResourceApplicationCache.get()))
     99                 return true;
    100         }
    101     }
    102     return false;
    103 }
    104 
    105 bool ApplicationCacheHost::maybeLoadFallbackForMainError(const ResourceRequest& request, const ResourceError& error)
    106 {
    107     if (!error.isCancellation()) {
    108         ASSERT(!m_mainResourceApplicationCache);
    109         if (isApplicationCacheEnabled()) {
    110             m_mainResourceApplicationCache = ApplicationCacheGroup::fallbackCacheForMainRequest(request, m_documentLoader);
    111 
    112             if (scheduleLoadFallbackResourceFromApplicationCache(documentLoader()->mainResourceLoader(), m_mainResourceApplicationCache.get()))
    113                 return true;
    114         }
    115     }
    116     return false;
    117 }
    118 
    119 void ApplicationCacheHost::mainResourceDataReceived(const char*, int, long long, bool)
    120 {
    121     // This method is here to facilitate alternate implemetations of this interface by the host browser.
    122 }
    123 
    124 void ApplicationCacheHost::failedLoadingMainResource()
    125 {
    126     ApplicationCacheGroup* group = m_candidateApplicationCacheGroup;
    127     if (!group && m_applicationCache) {
    128         ASSERT(!mainResourceApplicationCache()); // If the main resource were loaded from a cache, it wouldn't fail.
    129         group = m_applicationCache->group();
    130     }
    131 
    132     if (group)
    133         group->failedLoadingMainResource(m_documentLoader);
    134 }
    135 
    136 void ApplicationCacheHost::finishedLoadingMainResource()
    137 {
    138     ApplicationCacheGroup* group = candidateApplicationCacheGroup();
    139     if (!group && applicationCache() && !mainResourceApplicationCache())
    140         group = applicationCache()->group();
    141 
    142     if (group)
    143         group->finishedLoadingMainResource(m_documentLoader);
    144 }
    145 
    146 bool ApplicationCacheHost::maybeLoadResource(ResourceLoader* loader, ResourceRequest& request, const KURL& originalURL)
    147 {
    148     if (!isApplicationCacheEnabled())
    149         return false;
    150 
    151     if (request.url() != originalURL)
    152         return false;
    153 
    154     ApplicationCacheResource* resource;
    155     if (!shouldLoadResourceFromApplicationCache(request, resource))
    156         return false;
    157 
    158     m_documentLoader->m_pendingSubstituteResources.set(loader, resource);
    159     m_documentLoader->deliverSubstituteResourcesAfterDelay();
    160 
    161     return true;
    162 }
    163 
    164 bool ApplicationCacheHost::maybeLoadFallbackForRedirect(ResourceLoader* resourceLoader, ResourceRequest& request, const ResourceResponse& redirectResponse)
    165 {
    166     if (!redirectResponse.isNull() && !protocolHostAndPortAreEqual(request.url(), redirectResponse.url()))
    167         if (scheduleLoadFallbackResourceFromApplicationCache(resourceLoader))
    168             return true;
    169     return false;
    170 }
    171 
    172 bool ApplicationCacheHost::maybeLoadFallbackForResponse(ResourceLoader* resourceLoader, const ResourceResponse& response)
    173 {
    174     if (response.httpStatusCode() / 100 == 4 || response.httpStatusCode() / 100 == 5)
    175         if (scheduleLoadFallbackResourceFromApplicationCache(resourceLoader))
    176             return true;
    177     return false;
    178 }
    179 
    180 bool ApplicationCacheHost::maybeLoadFallbackForError(ResourceLoader* resourceLoader, const ResourceError& error)
    181 {
    182     if (!error.isCancellation())
    183         if (scheduleLoadFallbackResourceFromApplicationCache(resourceLoader))
    184             return true;
    185     return false;
    186 }
    187 
    188 bool ApplicationCacheHost::maybeLoadSynchronously(ResourceRequest& request, ResourceError& error, ResourceResponse& response, Vector<char>& data)
    189 {
    190     ApplicationCacheResource* resource;
    191     if (shouldLoadResourceFromApplicationCache(request, resource)) {
    192         if (resource) {
    193             response = resource->response();
    194             data.append(resource->data()->data(), resource->data()->size());
    195         } else {
    196             error = documentLoader()->frameLoader()->client()->cannotShowURLError(request);
    197         }
    198         return true;
    199     }
    200     return false;
    201 }
    202 
    203 void ApplicationCacheHost::maybeLoadFallbackSynchronously(const ResourceRequest& request, ResourceError& error, ResourceResponse& response, Vector<char>& data)
    204 {
    205     // If normal loading results in a redirect to a resource with another origin (indicative of a captive portal), or a 4xx or 5xx status code or equivalent,
    206     // or if there were network errors (but not if the user canceled the download), then instead get, from the cache, the resource of the fallback entry
    207     // corresponding to the matched namespace.
    208     if ((!error.isNull() && !error.isCancellation())
    209          || response.httpStatusCode() / 100 == 4 || response.httpStatusCode() / 100 == 5
    210          || !protocolHostAndPortAreEqual(request.url(), response.url())) {
    211         ApplicationCacheResource* resource;
    212         if (getApplicationCacheFallbackResource(request, resource)) {
    213             response = resource->response();
    214             data.clear();
    215             data.append(resource->data()->data(), resource->data()->size());
    216         }
    217     }
    218 }
    219 
    220 bool ApplicationCacheHost::canCacheInPageCache() const
    221 {
    222     return !applicationCache() && !candidateApplicationCacheGroup();
    223 }
    224 
    225 void ApplicationCacheHost::setDOMApplicationCache(DOMApplicationCache* domApplicationCache)
    226 {
    227     ASSERT(!m_domApplicationCache || !domApplicationCache);
    228     m_domApplicationCache = domApplicationCache;
    229 }
    230 
    231 void ApplicationCacheHost::notifyDOMApplicationCache(EventID id)
    232 {
    233     if (m_defersEvents) {
    234         // Events are deferred until document.onload has fired.
    235         m_deferredEvents.append(id);
    236         return;
    237     }
    238     if (m_domApplicationCache) {
    239         ExceptionCode ec = 0;
    240         m_domApplicationCache->dispatchEvent(Event::create(DOMApplicationCache::toEventType(id), false, false), ec);
    241         ASSERT(!ec);
    242     }
    243 }
    244 
    245 void ApplicationCacheHost::stopDeferringEvents()
    246 {
    247     RefPtr<DocumentLoader> protect(documentLoader());
    248     for (unsigned i = 0; i < m_deferredEvents.size(); ++i) {
    249         EventID id = m_deferredEvents[i];
    250         if (m_domApplicationCache) {
    251             ExceptionCode ec = 0;
    252             m_domApplicationCache->dispatchEvent(Event::create(DOMApplicationCache::toEventType(id), false, false), ec);
    253             ASSERT(!ec);
    254         }
    255     }
    256     m_deferredEvents.clear();
    257     m_defersEvents = false;
    258 }
    259 
    260 void ApplicationCacheHost::setCandidateApplicationCacheGroup(ApplicationCacheGroup* group)
    261 {
    262     ASSERT(!m_applicationCache);
    263     m_candidateApplicationCacheGroup = group;
    264 }
    265 
    266 void ApplicationCacheHost::setApplicationCache(PassRefPtr<ApplicationCache> applicationCache)
    267 {
    268     if (m_candidateApplicationCacheGroup) {
    269         ASSERT(!m_applicationCache);
    270         m_candidateApplicationCacheGroup = 0;
    271     }
    272 
    273     m_applicationCache = applicationCache;
    274 }
    275 
    276 bool ApplicationCacheHost::shouldLoadResourceFromApplicationCache(const ResourceRequest& request, ApplicationCacheResource*& resource)
    277 {
    278     ApplicationCache* cache = applicationCache();
    279     if (!cache || !cache->isComplete())
    280         return false;
    281 
    282     // If the resource is not to be fetched using the HTTP GET mechanism or equivalent, or if its URL has a different
    283     // <scheme> component than the application cache's manifest, then fetch the resource normally.
    284     if (!ApplicationCache::requestIsHTTPOrHTTPSGet(request) || !equalIgnoringCase(request.url().protocol(), cache->manifestResource()->url().protocol()))
    285         return false;
    286 
    287     // If the resource's URL is an master entry, the manifest, an explicit entry, or a fallback entry
    288     // in the application cache, then get the resource from the cache (instead of fetching it).
    289     resource = cache->resourceForURL(request.url());
    290 
    291     // Resources that match fallback namespaces or online whitelist entries are fetched from the network,
    292     // unless they are also cached.
    293     if (!resource && (cache->urlMatchesFallbackNamespace(request.url()) || cache->isURLInOnlineWhitelist(request.url())))
    294         return false;
    295 
    296     // Resources that are not present in the manifest will always fail to load (at least, after the
    297     // cache has been primed the first time), making the testing of offline applications simpler.
    298     return true;
    299 }
    300 
    301 bool ApplicationCacheHost::getApplicationCacheFallbackResource(const ResourceRequest& request, ApplicationCacheResource*& resource, ApplicationCache* cache)
    302 {
    303     if (!cache) {
    304         cache = applicationCache();
    305         if (!cache)
    306             return false;
    307     }
    308     if (!cache->isComplete())
    309         return false;
    310 
    311     // If the resource is not a HTTP/HTTPS GET, then abort
    312     if (!ApplicationCache::requestIsHTTPOrHTTPSGet(request))
    313         return false;
    314 
    315     KURL fallbackURL;
    316     if (!cache->urlMatchesFallbackNamespace(request.url(), &fallbackURL))
    317         return false;
    318 
    319     resource = cache->resourceForURL(fallbackURL);
    320     ASSERT(resource);
    321 
    322     return true;
    323 }
    324 
    325 bool ApplicationCacheHost::scheduleLoadFallbackResourceFromApplicationCache(ResourceLoader* loader, ApplicationCache* cache)
    326 {
    327     if (!isApplicationCacheEnabled())
    328         return false;
    329 
    330     ApplicationCacheResource* resource;
    331     if (!getApplicationCacheFallbackResource(loader->request(), resource, cache))
    332         return false;
    333 
    334     m_documentLoader->m_pendingSubstituteResources.set(loader, resource);
    335     m_documentLoader->deliverSubstituteResourcesAfterDelay();
    336 
    337     loader->handle()->cancel();
    338 
    339     return true;
    340 }
    341 
    342 ApplicationCacheHost::Status ApplicationCacheHost::status() const
    343 {
    344     ApplicationCache* cache = applicationCache();
    345     if (!cache)
    346         return UNCACHED;
    347 
    348     switch (cache->group()->updateStatus()) {
    349         case ApplicationCacheGroup::Checking:
    350             return CHECKING;
    351         case ApplicationCacheGroup::Downloading:
    352             return DOWNLOADING;
    353         case ApplicationCacheGroup::Idle: {
    354             if (cache->group()->isObsolete())
    355                 return OBSOLETE;
    356             if (cache != cache->group()->newestCache())
    357                 return UPDATEREADY;
    358             return IDLE;
    359         }
    360     }
    361 
    362     ASSERT_NOT_REACHED();
    363     return UNCACHED;
    364 }
    365 
    366 bool ApplicationCacheHost::update()
    367 {
    368     ApplicationCache* cache = applicationCache();
    369     if (!cache)
    370         return false;
    371     cache->group()->update(m_documentLoader->frame(), ApplicationCacheUpdateWithoutBrowsingContext);
    372     return true;
    373 }
    374 
    375 bool ApplicationCacheHost::swapCache()
    376 {
    377     ApplicationCache* cache = applicationCache();
    378     if (!cache)
    379         return false;
    380 
    381     // If the group of application caches to which cache belongs has the lifecycle status obsolete, unassociate document from cache.
    382     if (cache->group()->isObsolete()) {
    383         cache->group()->disassociateDocumentLoader(m_documentLoader);
    384         return true;
    385     }
    386 
    387     // If there is no newer cache, raise an INVALID_STATE_ERR exception.
    388     ApplicationCache* newestCache = cache->group()->newestCache();
    389     if (cache == newestCache)
    390         return false;
    391 
    392     ASSERT(cache->group() == newestCache->group());
    393     setApplicationCache(newestCache);
    394 
    395     return true;
    396 }
    397 
    398 bool ApplicationCacheHost::isApplicationCacheEnabled()
    399 {
    400     return m_documentLoader->frame()->settings()
    401            && m_documentLoader->frame()->settings()->offlineWebApplicationCacheEnabled();
    402 }
    403 
    404 }  // namespace WebCore
    405 
    406 #endif  // ENABLE(OFFLINE_WEB_APPLICATIONS)
    407