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