WebCore/loader/appcache/ApplicationCacheHost.cpp

   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 "ProgressEvent.h"
  41 #include "ResourceLoader.h"
  42 #include "ResourceRequest.h"
  43 #include "Settings.h"
  44
  45 namespace WebCore {
  46
  47 ApplicationCacheHost::ApplicationCacheHost(DocumentLoader* documentLoader)
  48     : m_domApplicationCache(0)
  49     , m_documentLoader(documentLoader)
  50     , m_defersEvents(true)
  51     , m_candidateApplicationCacheGroup(0)
  52 {
  53     ASSERT(m_documentLoader);
  54 }
  55
  56 ApplicationCacheHost::~ApplicationCacheHost()
  57 {
  58     if (m_applicationCache)
  59         m_applicationCache->group()->disassociateDocumentLoader(m_documentLoader);
  60     else if (m_candidateApplicationCacheGroup)
  61         m_candidateApplicationCacheGroup->disassociateDocumentLoader(m_documentLoader);
  62 }
  63
  64 void ApplicationCacheHost::selectCacheWithoutManifest()
  65 {
  66     ApplicationCacheGroup::selectCacheWithoutManifestURL(m_documentLoader->frame());
  67 }
  68
  69 void ApplicationCacheHost::selectCacheWithManifest(const KURL& manifestURL)
  70 {
  71     ApplicationCacheGroup::selectCache(m_documentLoader->frame(), manifestURL);
  72 }
  73
  74 void ApplicationCacheHost::maybeLoadMainResource(ResourceRequest& request, SubstituteData& substituteData)
  75 {
  76     // Check if this request should be loaded from the application cache
  77     if (!substituteData.isValid() && isApplicationCacheEnabled()) {
  78         ASSERT(!m_mainResourceApplicationCache);
  79
  80         m_mainResourceApplicationCache = ApplicationCacheGroup::cacheForMainRequest(request, m_documentLoader);
  81
  82         if (m_mainResourceApplicationCache) {
  83             // Get the resource from the application cache. By definition, cacheForMainRequest() returns a cache that contains the resource.
  84             ApplicationCacheResource* resource = m_mainResourceApplicationCache->resourceForRequest(request);
  85             substituteData = SubstituteData(resource->data(),
  86                                             resource->response().mimeType(),
  87                                             resource->response().textEncodingName(), KURL());
  88         }
  89     }
  90 }
  91
  92 bool ApplicationCacheHost::maybeLoadFallbackForMainResponse(const ResourceRequest& request, const ResourceResponse& r)
  93 {
  94     if (r.httpStatusCode() / 100 == 4 || r.httpStatusCode() / 100 == 5) {
  95         ASSERT(!m_mainResourceApplicationCache);
  96         if (isApplicationCacheEnabled()) {
  97             m_mainResourceApplicationCache = ApplicationCacheGroup::fallbackCacheForMainRequest(request, documentLoader());
  98
  99             if (scheduleLoadFallbackResourceFromApplicationCache(documentLoader()->mainResourceLoader(), m_mainResourceApplicationCache.get()))
 100                 return true;
 101         }
 102     }
 103     return false;
 104 }
 105
 106 bool ApplicationCacheHost::maybeLoadFallbackForMainError(const ResourceRequest& request, const ResourceError& error)
 107 {
 108     if (!error.isCancellation()) {
 109         ASSERT(!m_mainResourceApplicationCache);
 110         if (isApplicationCacheEnabled()) {
 111             m_mainResourceApplicationCache = ApplicationCacheGroup::fallbackCacheForMainRequest(request, m_documentLoader);
 112
 113             if (scheduleLoadFallbackResourceFromApplicationCache(documentLoader()->mainResourceLoader(), m_mainResourceApplicationCache.get()))
 114                 return true;
 115         }
 116     }
 117     return false;
 118 }
 119
 120 void ApplicationCacheHost::mainResourceDataReceived(const char*, int, long long, bool)
 121 {
 122     // This method is here to facilitate alternate implemetations of this interface by the host browser.
 123 }
 124
 125 void ApplicationCacheHost::failedLoadingMainResource()
 126 {
 127     ApplicationCacheGroup* group = m_candidateApplicationCacheGroup;
 128     if (!group && m_applicationCache) {
 129         ASSERT(!mainResourceApplicationCache()); // If the main resource were loaded from a cache, it wouldn't fail.
 130         group = m_applicationCache->group();
 131     }
 132
 133     if (group)
 134         group->failedLoadingMainResource(m_documentLoader);
 135 }
 136
 137 void ApplicationCacheHost::finishedLoadingMainResource()
 138 {
 139     ApplicationCacheGroup* group = candidateApplicationCacheGroup();
 140     if (!group && applicationCache() && !mainResourceApplicationCache())
 141         group = applicationCache()->group();
 142
 143     if (group)
 144         group->finishedLoadingMainResource(m_documentLoader);
 145 }
 146
 147 bool ApplicationCacheHost::maybeLoadResource(ResourceLoader* loader, ResourceRequest& request, const KURL& originalURL)
 148 {
 149     if (!isApplicationCacheEnabled())
 150         return false;
 151
 152     if (request.url() != originalURL)
 153         return false;
 154
 155     ApplicationCacheResource* resource;
 156     if (!shouldLoadResourceFromApplicationCache(request, resource))
 157         return false;
 158
 159     m_documentLoader->m_pendingSubstituteResources.set(loader, resource);
 160     m_documentLoader->deliverSubstituteResourcesAfterDelay();
 161
 162     return true;
 163 }
 164
 165 bool ApplicationCacheHost::maybeLoadFallbackForRedirect(ResourceLoader* resourceLoader, ResourceRequest& request, const ResourceResponse& redirectResponse)
 166 {
 167     if (!redirectResponse.isNull() && !protocolHostAndPortAreEqual(request.url(), redirectResponse.url()))
 168         if (scheduleLoadFallbackResourceFromApplicationCache(resourceLoader))
 169             return true;
 170     return false;
 171 }
 172
 173 bool ApplicationCacheHost::maybeLoadFallbackForResponse(ResourceLoader* resourceLoader, const ResourceResponse& response)
 174 {
 175     if (response.httpStatusCode() / 100 == 4 || response.httpStatusCode() / 100 == 5)
 176         if (scheduleLoadFallbackResourceFromApplicationCache(resourceLoader))
 177             return true;
 178     return false;
 179 }
 180
 181 bool ApplicationCacheHost::maybeLoadFallbackForError(ResourceLoader* resourceLoader, const ResourceError& error)
 182 {
 183     if (!error.isCancellation())
 184         if (scheduleLoadFallbackResourceFromApplicationCache(resourceLoader))
 185             return true;
 186     return false;
 187 }
 188
 189 bool ApplicationCacheHost::maybeLoadSynchronously(ResourceRequest& request, ResourceError& error, ResourceResponse& response, Vector<char>& data)
 190 {
 191     ApplicationCacheResource* resource;
 192     if (shouldLoadResourceFromApplicationCache(request, resource)) {
 193         if (resource) {
 194             response = resource->response();
 195             data.append(resource->data()->data(), resource->data()->size());
 196         } else {
 197             error = documentLoader()->frameLoader()->client()->cannotShowURLError(request);
 198         }
 199         return true;
 200     }
 201     return false;
 202 }
 203
 204 void ApplicationCacheHost::maybeLoadFallbackSynchronously(const ResourceRequest& request, ResourceError& error, ResourceResponse& response, Vector<char>& data)
 205 {
 206     // 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,
 207     // 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
 208     // corresponding to the matched namespace.
 209     if ((!error.isNull() && !error.isCancellation())
 210          || response.httpStatusCode() / 100 == 4 || response.httpStatusCode() / 100 == 5
 211          || !protocolHostAndPortAreEqual(request.url(), response.url())) {
 212         ApplicationCacheResource* resource;
 213         if (getApplicationCacheFallbackResource(request, resource)) {
 214             response = resource->response();
 215             data.clear();
 216             data.append(resource->data()->data(), resource->data()->size());
 217         }
 218     }
 219 }
 220
 221 bool ApplicationCacheHost::canCacheInPageCache() const
 222 {
 223     return !applicationCache() && !candidateApplicationCacheGroup();
 224 }
 225
 226 void ApplicationCacheHost::setDOMApplicationCache(DOMApplicationCache* domApplicationCache)
 227 {
 228     ASSERT(!m_domApplicationCache || !domApplicationCache);
 229     m_domApplicationCache = domApplicationCache;
 230 }
 231
 232 void ApplicationCacheHost::notifyDOMApplicationCache(EventID id, int total, int done)
 233 {
 234     if (m_defersEvents) {
 235         // Event dispatching is deferred until document.onload has fired.
 236         m_deferredEvents.append(DeferredEvent(id, total, done));
 237         return;
 238     }
 239     dispatchDOMEvent(id, total, done);
 240 }
 241
 242 void ApplicationCacheHost::stopDeferringEvents()
 243 {
 244     RefPtr<DocumentLoader> protect(documentLoader());
 245     for (unsigned i = 0; i < m_deferredEvents.size(); ++i) {
 246         const DeferredEvent& deferred = m_deferredEvents[i];
 247         dispatchDOMEvent(deferred.eventID, deferred.progressTotal, deferred.progressDone);
 248     }
 249     m_deferredEvents.clear();
 250     m_defersEvents = false;
 251 }
 252
 253 void ApplicationCacheHost::dispatchDOMEvent(EventID id, int total, int done)
 254 {
 255     if (m_domApplicationCache) {
 256         const AtomicString& eventType = DOMApplicationCache::toEventType(id);
 257         ExceptionCode ec = 0;
 258         RefPtr<Event> event;
 259         if (id == PROGRESS_EVENT)
 260             event = ProgressEvent::create(eventType, true, done, total);
 261         else
 262             event = Event::create(eventType, false, false);
 263         m_domApplicationCache->dispatchEvent(event, ec);
 264         ASSERT(!ec);
 265     }
 266 }
 267
 268 void ApplicationCacheHost::setCandidateApplicationCacheGroup(ApplicationCacheGroup* group)
 269 {
 270     ASSERT(!m_applicationCache);
 271     m_candidateApplicationCacheGroup = group;
 272 }
 273
 274 void ApplicationCacheHost::setApplicationCache(PassRefPtr<ApplicationCache> applicationCache)
 275 {
 276     if (m_candidateApplicationCacheGroup) {
 277         ASSERT(!m_applicationCache);
 278         m_candidateApplicationCacheGroup = 0;
 279     }
 280
 281     m_applicationCache = applicationCache;
 282 }
 283
 284 bool ApplicationCacheHost::shouldLoadResourceFromApplicationCache(const ResourceRequest& request, ApplicationCacheResource*& resource)
 285 {
 286     ApplicationCache* cache = applicationCache();
 287     if (!cache || !cache->isComplete())
 288         return false;
 289
 290     // If the resource is not to be fetched using the HTTP GET mechanism or equivalent, or if its URL has a different
 291     // <scheme> component than the application cache's manifest, then fetch the resource normally.
 292     if (!ApplicationCache::requestIsHTTPOrHTTPSGet(request) || !equalIgnoringCase(request.url().protocol(), cache->manifestResource()->url().protocol()))
 293         return false;
 294
 295     // If the resource's URL is an master entry, the manifest, an explicit entry, or a fallback entry
 296     // in the application cache, then get the resource from the cache (instead of fetching it).
 297     resource = cache->resourceForURL(request.url());
 298
 299     // Resources that match fallback namespaces or online whitelist entries are fetched from the network,
 300     // unless they are also cached.
 301     if (!resource && (cache->urlMatchesFallbackNamespace(request.url()) || cache->isURLInOnlineWhitelist(request.url())))
 302         return false;
 303
 304     // Resources that are not present in the manifest will always fail to load (at least, after the
 305     // cache has been primed the first time), making the testing of offline applications simpler.
 306     return true;
 307 }
 308
 309 bool ApplicationCacheHost::getApplicationCacheFallbackResource(const ResourceRequest& request, ApplicationCacheResource*& resource, ApplicationCache* cache)
 310 {
 311     if (!cache) {
 312         cache = applicationCache();
 313         if (!cache)
 314             return false;
 315     }
 316     if (!cache->isComplete())
 317         return false;
 318
 319     // If the resource is not a HTTP/HTTPS GET, then abort
 320     if (!ApplicationCache::requestIsHTTPOrHTTPSGet(request))
 321         return false;
 322
 323     KURL fallbackURL;
 324     if (!cache->urlMatchesFallbackNamespace(request.url(), &fallbackURL))
 325         return false;
 326
 327     resource = cache->resourceForURL(fallbackURL);
 328     ASSERT(resource);
 329
 330     return true;
 331 }
 332
 333 bool ApplicationCacheHost::scheduleLoadFallbackResourceFromApplicationCache(ResourceLoader* loader, ApplicationCache* cache)
 334 {
 335     if (!isApplicationCacheEnabled())
 336         return false;
 337
 338     ApplicationCacheResource* resource;
 339     if (!getApplicationCacheFallbackResource(loader->request(), resource, cache))
 340         return false;
 341
 342     m_documentLoader->m_pendingSubstituteResources.set(loader, resource);
 343     m_documentLoader->deliverSubstituteResourcesAfterDelay();
 344
 345     loader->handle()->cancel();
 346
 347     return true;
 348 }
 349
 350 ApplicationCacheHost::Status ApplicationCacheHost::status() const
 351 {
 352     ApplicationCache* cache = applicationCache();
 353     if (!cache)
 354         return UNCACHED;
 355
 356     switch (cache->group()->updateStatus()) {
 357         case ApplicationCacheGroup::Checking:
 358             return CHECKING;
 359         case ApplicationCacheGroup::Downloading:
 360             return DOWNLOADING;
 361         case ApplicationCacheGroup::Idle: {
 362             if (cache->group()->isObsolete())
 363                 return OBSOLETE;
 364             if (cache != cache->group()->newestCache())
 365                 return UPDATEREADY;
 366             return IDLE;
 367         }
 368     }
 369
 370     ASSERT_NOT_REACHED();
 371     return UNCACHED;
 372 }
 373
 374 bool ApplicationCacheHost::update()
 375 {
 376     ApplicationCache* cache = applicationCache();
 377     if (!cache)
 378         return false;
 379     cache->group()->update(m_documentLoader->frame(), ApplicationCacheUpdateWithoutBrowsingContext);
 380     return true;
 381 }
 382
 383 bool ApplicationCacheHost::swapCache()
 384 {
 385     ApplicationCache* cache = applicationCache();
 386     if (!cache)
 387         return false;
 388
 389     // If the group of application caches to which cache belongs has the lifecycle status obsolete, unassociate document from cache.
 390     if (cache->group()->isObsolete()) {
 391         cache->group()->disassociateDocumentLoader(m_documentLoader);
 392         return true;
 393     }
 394
 395     // If there is no newer cache, raise an INVALID_STATE_ERR exception.
 396     ApplicationCache* newestCache = cache->group()->newestCache();
 397     if (cache == newestCache)
 398         return false;
 399
 400     ASSERT(cache->group() == newestCache->group());
 401     setApplicationCache(newestCache);
 402
 403     return true;
 404 }
 405
 406 bool ApplicationCacheHost::isApplicationCacheEnabled()
 407 {
 408     return m_documentLoader->frame()->settings()
 409            && m_documentLoader->frame()->settings()->offlineWebApplicationCacheEnabled();
 410 }
 411
 412 }  // namespace WebCore
 413
 414 #endif  // ENABLE(OFFLINE_WEB_APPLICATIONS)