45b184cff997022a0a72e47fdb38d89ea9923442
[WebKit-https.git] / Source / WebCore / loader / appcache / ApplicationCacheGroup.cpp
1 /*
2  * Copyright (C) 2008, 2009, 2010 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 "ApplicationCacheGroup.h"
28
29 #if ENABLE(OFFLINE_WEB_APPLICATIONS)
30
31 #include "ApplicationCache.h"
32 #include "ApplicationCacheHost.h"
33 #include "ApplicationCacheResource.h"
34 #include "ApplicationCacheStorage.h"
35 #include "Chrome.h"
36 #include "ChromeClient.h"
37 #include "Console.h"
38 #include "DOMApplicationCache.h"
39 #include "DOMWindow.h"
40 #include "DocumentLoader.h"
41 #include "Frame.h"
42 #include "FrameLoader.h"
43 #include "FrameLoaderClient.h"
44 #include "InspectorInstrumentation.h"
45 #include "MainResourceLoader.h"
46 #include "ManifestParser.h"
47 #include "Page.h"
48 #include "ScriptProfile.h"
49 #include "SecurityOrigin.h"
50 #include "Settings.h"
51 #include <wtf/HashMap.h>
52 #include <wtf/UnusedParam.h>
53
54 #if ENABLE(INSPECTOR)
55 #include "ProgressTracker.h"
56 #endif
57
58 namespace WebCore {
59
60 ApplicationCacheGroup::ApplicationCacheGroup(const KURL& manifestURL, bool isCopy)
61     : m_manifestURL(manifestURL)
62     , m_origin(SecurityOrigin::create(manifestURL))
63     , m_updateStatus(Idle)
64     , m_downloadingPendingMasterResourceLoadersCount(0)
65     , m_progressTotal(0)
66     , m_progressDone(0)
67     , m_frame(0)
68     , m_storageID(0)
69     , m_isObsolete(false)
70     , m_completionType(None)
71     , m_isCopy(isCopy)
72     , m_calledReachedMaxAppCacheSize(false)
73     , m_loadedSize(0)
74     , m_availableSpaceInQuota(ApplicationCacheStorage::unknownQuota())
75     , m_originQuotaReached(false)
76 {
77 }
78
79 ApplicationCacheGroup::~ApplicationCacheGroup()
80 {
81     if (m_isCopy) {
82         ASSERT(m_newestCache);
83         ASSERT(m_caches.size() == 1);
84         ASSERT(m_caches.contains(m_newestCache.get()));
85         ASSERT(!m_cacheBeingUpdated);
86         ASSERT(m_associatedDocumentLoaders.isEmpty());
87         ASSERT(m_pendingMasterResourceLoaders.isEmpty());
88         ASSERT(m_newestCache->group() == this);
89         
90         return;
91     }
92                
93     ASSERT(!m_newestCache);
94     ASSERT(m_caches.isEmpty());
95     
96     stopLoading();
97     
98     cacheStorage().cacheGroupDestroyed(this);
99 }
100     
101 ApplicationCache* ApplicationCacheGroup::cacheForMainRequest(const ResourceRequest& request, DocumentLoader*)
102 {
103     if (!ApplicationCache::requestIsHTTPOrHTTPSGet(request))
104         return 0;
105
106     KURL url(request.url());
107     if (url.hasFragmentIdentifier())
108         url.removeFragmentIdentifier();
109
110     if (ApplicationCacheGroup* group = cacheStorage().cacheGroupForURL(url)) {
111         ASSERT(group->newestCache());
112         ASSERT(!group->isObsolete());
113         
114         return group->newestCache();
115     }
116     
117     return 0;
118 }
119     
120 ApplicationCache* ApplicationCacheGroup::fallbackCacheForMainRequest(const ResourceRequest& request, DocumentLoader*)
121 {
122     if (!ApplicationCache::requestIsHTTPOrHTTPSGet(request))
123         return 0;
124
125     KURL url(request.url());
126     if (url.hasFragmentIdentifier())
127         url.removeFragmentIdentifier();
128
129     if (ApplicationCacheGroup* group = cacheStorage().fallbackCacheGroupForURL(url)) {
130         ASSERT(group->newestCache());
131         ASSERT(!group->isObsolete());
132
133         return group->newestCache();
134     }
135     
136     return 0;
137 }
138
139 void ApplicationCacheGroup::selectCache(Frame* frame, const KURL& passedManifestURL)
140 {
141     ASSERT(frame && frame->page());
142     
143     if (!frame->settings()->offlineWebApplicationCacheEnabled())
144         return;
145     
146     DocumentLoader* documentLoader = frame->loader()->documentLoader();
147     ASSERT(!documentLoader->applicationCacheHost()->applicationCache());
148
149     if (passedManifestURL.isNull()) {
150         selectCacheWithoutManifestURL(frame);        
151         return;
152     }
153
154     KURL manifestURL(passedManifestURL);
155     if (manifestURL.hasFragmentIdentifier())
156         manifestURL.removeFragmentIdentifier();
157
158     ApplicationCache* mainResourceCache = documentLoader->applicationCacheHost()->mainResourceApplicationCache();
159     
160     if (mainResourceCache) {
161         if (manifestURL == mainResourceCache->group()->m_manifestURL) {
162             // The cache may have gotten obsoleted after we've loaded from it, but before we parsed the document and saw cache manifest.
163             if (mainResourceCache->group()->isObsolete())
164                 return;
165             mainResourceCache->group()->associateDocumentLoaderWithCache(documentLoader, mainResourceCache);
166             mainResourceCache->group()->update(frame, ApplicationCacheUpdateWithBrowsingContext);
167         } else {
168             // The main resource was loaded from cache, so the cache must have an entry for it. Mark it as foreign.
169             KURL resourceURL(documentLoader->responseURL());
170             if (resourceURL.hasFragmentIdentifier())
171                 resourceURL.removeFragmentIdentifier();
172             ApplicationCacheResource* resource = mainResourceCache->resourceForURL(resourceURL);
173             bool inStorage = resource->storageID();
174             resource->addType(ApplicationCacheResource::Foreign);
175             if (inStorage)
176                 cacheStorage().storeUpdatedType(resource, mainResourceCache);
177
178             // Restart the current navigation from the top of the navigation algorithm, undoing any changes that were made
179             // as part of the initial load.
180             // The navigation will not result in the same resource being loaded, because "foreign" entries are never picked during navigation.
181             frame->navigationScheduler()->scheduleLocationChange(frame->document()->securityOrigin(), documentLoader->url(), frame->loader()->referrer());
182         }
183         
184         return;
185     }
186     
187     // The resource was loaded from the network, check if it is a HTTP/HTTPS GET.    
188     const ResourceRequest& request = frame->loader()->activeDocumentLoader()->request();
189
190     if (!ApplicationCache::requestIsHTTPOrHTTPSGet(request))
191         return;
192
193     // Check that the resource URL has the same scheme/host/port as the manifest URL.
194     if (!protocolHostAndPortAreEqual(manifestURL, request.url()))
195         return;
196
197     // Don't change anything on disk if private browsing is enabled.
198     if (!frame->settings() || frame->settings()->privateBrowsingEnabled()) {
199         postListenerTask(ApplicationCacheHost::CHECKING_EVENT, documentLoader);
200         postListenerTask(ApplicationCacheHost::ERROR_EVENT, documentLoader);
201         return;
202     }
203
204     ApplicationCacheGroup* group = cacheStorage().findOrCreateCacheGroup(manifestURL);
205
206     documentLoader->applicationCacheHost()->setCandidateApplicationCacheGroup(group);
207     group->m_pendingMasterResourceLoaders.add(documentLoader);
208     group->m_downloadingPendingMasterResourceLoadersCount++;
209
210     ASSERT(!group->m_cacheBeingUpdated || group->m_updateStatus != Idle);
211     group->update(frame, ApplicationCacheUpdateWithBrowsingContext);
212 }
213
214 void ApplicationCacheGroup::selectCacheWithoutManifestURL(Frame* frame)
215 {
216     if (!frame->settings()->offlineWebApplicationCacheEnabled())
217         return;
218
219     DocumentLoader* documentLoader = frame->loader()->documentLoader();
220     ASSERT(!documentLoader->applicationCacheHost()->applicationCache());
221
222     ApplicationCache* mainResourceCache = documentLoader->applicationCacheHost()->mainResourceApplicationCache();
223
224     if (mainResourceCache) {
225         mainResourceCache->group()->associateDocumentLoaderWithCache(documentLoader, mainResourceCache);
226         mainResourceCache->group()->update(frame, ApplicationCacheUpdateWithBrowsingContext);
227     }
228 }
229
230 void ApplicationCacheGroup::finishedLoadingMainResource(DocumentLoader* loader)
231 {
232     ASSERT(m_pendingMasterResourceLoaders.contains(loader));
233     ASSERT(m_completionType == None || m_pendingEntries.isEmpty());
234     KURL url = loader->url();
235     if (url.hasFragmentIdentifier())
236         url.removeFragmentIdentifier();
237
238     switch (m_completionType) {
239     case None:
240         // The main resource finished loading before the manifest was ready. It will be handled via dispatchMainResources() later.
241         return;
242     case NoUpdate:
243         ASSERT(!m_cacheBeingUpdated);
244         associateDocumentLoaderWithCache(loader, m_newestCache.get());
245
246         if (ApplicationCacheResource* resource = m_newestCache->resourceForURL(url)) {
247             if (!(resource->type() & ApplicationCacheResource::Master)) {
248                 resource->addType(ApplicationCacheResource::Master);
249                 ASSERT(!resource->storageID());
250             }
251         } else
252             m_newestCache->addResource(ApplicationCacheResource::create(url, loader->response(), ApplicationCacheResource::Master, loader->mainResourceData()));
253
254         break;
255     case Failure:
256         // Cache update has been a failure, so there is no reason to keep the document associated with the incomplete cache
257         // (its main resource was not cached yet, so it is likely that the application changed significantly server-side).
258         ASSERT(!m_cacheBeingUpdated); // Already cleared out by stopLoading().
259         loader->applicationCacheHost()->setApplicationCache(0); // Will unset candidate, too.
260         m_associatedDocumentLoaders.remove(loader);
261         postListenerTask(ApplicationCacheHost::ERROR_EVENT, loader);
262         break;
263     case Completed:
264         ASSERT(m_associatedDocumentLoaders.contains(loader));
265
266         if (ApplicationCacheResource* resource = m_cacheBeingUpdated->resourceForURL(url)) {
267             if (!(resource->type() & ApplicationCacheResource::Master)) {
268                 resource->addType(ApplicationCacheResource::Master);
269                 ASSERT(!resource->storageID());
270             }
271         } else
272             m_cacheBeingUpdated->addResource(ApplicationCacheResource::create(url, loader->response(), ApplicationCacheResource::Master, loader->mainResourceData()));
273         // The "cached" event will be posted to all associated documents once update is complete.
274         break;
275     }
276
277     ASSERT(m_downloadingPendingMasterResourceLoadersCount > 0);
278     m_downloadingPendingMasterResourceLoadersCount--;
279     checkIfLoadIsComplete();
280 }
281
282 void ApplicationCacheGroup::failedLoadingMainResource(DocumentLoader* loader)
283 {
284     ASSERT(m_pendingMasterResourceLoaders.contains(loader));
285     ASSERT(m_completionType == None || m_pendingEntries.isEmpty());
286
287     switch (m_completionType) {
288     case None:
289         // The main resource finished loading before the manifest was ready. It will be handled via dispatchMainResources() later.
290         return;
291     case NoUpdate:
292         ASSERT(!m_cacheBeingUpdated);
293
294         // The manifest didn't change, and we have a relevant cache - but the main resource download failed mid-way, so it cannot be stored to the cache,
295         // and the loader does not get associated to it. If there are other main resources being downloaded for this cache group, they may still succeed.
296         postListenerTask(ApplicationCacheHost::ERROR_EVENT, loader);
297
298         break;
299     case Failure:
300         // Cache update failed, too.
301         ASSERT(!m_cacheBeingUpdated); // Already cleared out by stopLoading().
302         ASSERT(!loader->applicationCacheHost()->applicationCache() || loader->applicationCacheHost()->applicationCache() == m_cacheBeingUpdated);
303
304         loader->applicationCacheHost()->setApplicationCache(0); // Will unset candidate, too.
305         m_associatedDocumentLoaders.remove(loader);
306         postListenerTask(ApplicationCacheHost::ERROR_EVENT, loader);
307         break;
308     case Completed:
309         // The cache manifest didn't list this main resource, and all cache entries were already updated successfully - but the main resource failed to load,
310         // so it cannot be stored to the cache. If there are other main resources being downloaded for this cache group, they may still succeed.
311         ASSERT(m_associatedDocumentLoaders.contains(loader));
312         ASSERT(loader->applicationCacheHost()->applicationCache() == m_cacheBeingUpdated);
313         ASSERT(!loader->applicationCacheHost()->candidateApplicationCacheGroup());
314         m_associatedDocumentLoaders.remove(loader);
315         loader->applicationCacheHost()->setApplicationCache(0);
316
317         postListenerTask(ApplicationCacheHost::ERROR_EVENT, loader);
318
319         break;
320     }
321
322     ASSERT(m_downloadingPendingMasterResourceLoadersCount > 0);
323     m_downloadingPendingMasterResourceLoadersCount--;
324     checkIfLoadIsComplete();
325 }
326
327 void ApplicationCacheGroup::stopLoading()
328 {
329     if (m_manifestHandle) {
330         ASSERT(!m_currentHandle);
331
332         ASSERT(m_manifestHandle->client() == this);
333         m_manifestHandle->setClient(0);
334
335         m_manifestHandle->cancel();
336         m_manifestHandle = 0;
337     }
338     
339     if (m_currentHandle) {
340         ASSERT(!m_manifestHandle);
341         ASSERT(m_cacheBeingUpdated);
342
343         ASSERT(m_currentHandle->client() == this);
344         m_currentHandle->setClient(0);
345
346         m_currentHandle->cancel();
347         m_currentHandle = 0;
348     }    
349
350     // FIXME: Resetting just a tiny part of the state in this function is confusing. Callers have to take care of a lot more.
351     m_cacheBeingUpdated = 0;
352     m_pendingEntries.clear();
353 }    
354
355 void ApplicationCacheGroup::disassociateDocumentLoader(DocumentLoader* loader)
356 {
357     HashSet<DocumentLoader*>::iterator it = m_associatedDocumentLoaders.find(loader);
358     if (it != m_associatedDocumentLoaders.end())
359         m_associatedDocumentLoaders.remove(it);
360
361     m_pendingMasterResourceLoaders.remove(loader);
362
363     loader->applicationCacheHost()->setApplicationCache(0); // Will set candidate to 0, too.
364
365     if (!m_associatedDocumentLoaders.isEmpty() || !m_pendingMasterResourceLoaders.isEmpty())
366         return;
367
368     if (m_caches.isEmpty()) {
369         // There is an initial cache attempt in progress.
370         ASSERT(!m_newestCache);
371         // Delete ourselves, causing the cache attempt to be stopped.
372         delete this;
373         return;
374     }
375
376     ASSERT(m_caches.contains(m_newestCache.get()));
377
378     // Release our reference to the newest cache. This could cause us to be deleted.
379     // Any ongoing updates will be stopped from destructor.
380     m_newestCache.release();
381 }
382
383 void ApplicationCacheGroup::cacheDestroyed(ApplicationCache* cache)
384 {
385     if (!m_caches.contains(cache))
386         return;
387     
388     m_caches.remove(cache);
389
390     if (m_caches.isEmpty()) {
391         ASSERT(m_associatedDocumentLoaders.isEmpty());
392         ASSERT(m_pendingMasterResourceLoaders.isEmpty());
393         delete this;
394     }
395 }
396
397 void ApplicationCacheGroup::stopLoadingInFrame(Frame* frame)
398 {
399     if (frame != m_frame)
400         return;
401
402     cacheUpdateFailed();
403 }
404
405 void ApplicationCacheGroup::setNewestCache(PassRefPtr<ApplicationCache> newestCache)
406 {
407     m_newestCache = newestCache;
408
409     m_caches.add(m_newestCache.get());
410     m_newestCache->setGroup(this);
411     InspectorInstrumentation::updateApplicationCacheStatus(m_frame);
412 }
413
414 void ApplicationCacheGroup::makeObsolete()
415 {
416     if (isObsolete())
417         return;
418
419     m_isObsolete = true;
420     cacheStorage().cacheGroupMadeObsolete(this);
421     ASSERT(!m_storageID);
422     InspectorInstrumentation::updateApplicationCacheStatus(m_frame);
423 }
424
425 void ApplicationCacheGroup::update(Frame* frame, ApplicationCacheUpdateOption updateOption)
426 {
427     if (m_updateStatus == Checking || m_updateStatus == Downloading) {
428         if (updateOption == ApplicationCacheUpdateWithBrowsingContext) {
429             postListenerTask(ApplicationCacheHost::CHECKING_EVENT, frame->loader()->documentLoader());
430             if (m_updateStatus == Downloading)
431                 postListenerTask(ApplicationCacheHost::DOWNLOADING_EVENT, frame->loader()->documentLoader());
432         }
433         return;
434     }
435
436     // Don't change anything on disk if private browsing is enabled.
437     if (!frame->settings() || frame->settings()->privateBrowsingEnabled()) {
438         ASSERT(m_pendingMasterResourceLoaders.isEmpty());
439         ASSERT(m_pendingEntries.isEmpty());
440         ASSERT(!m_cacheBeingUpdated);
441         postListenerTask(ApplicationCacheHost::CHECKING_EVENT, frame->loader()->documentLoader());
442         postListenerTask(ApplicationCacheHost::NOUPDATE_EVENT, frame->loader()->documentLoader());
443         return;
444     }
445
446     ASSERT(!m_frame);
447     m_frame = frame;
448
449     setUpdateStatus(Checking);
450
451     postListenerTask(ApplicationCacheHost::CHECKING_EVENT, m_associatedDocumentLoaders);
452     if (!m_newestCache) {
453         ASSERT(updateOption == ApplicationCacheUpdateWithBrowsingContext);
454         postListenerTask(ApplicationCacheHost::CHECKING_EVENT, frame->loader()->documentLoader());
455     }
456     
457     ASSERT(!m_manifestHandle);
458     ASSERT(!m_manifestResource);
459     ASSERT(!m_currentHandle);
460     ASSERT(!m_currentResource);
461     ASSERT(m_completionType == None);
462
463     // FIXME: Handle defer loading
464     m_manifestHandle = createResourceHandle(m_manifestURL, m_newestCache ? m_newestCache->manifestResource() : 0);
465 }
466
467 PassRefPtr<ResourceHandle> ApplicationCacheGroup::createResourceHandle(const KURL& url, ApplicationCacheResource* newestCachedResource)
468 {
469     ResourceRequest request(url);
470     m_frame->loader()->applyUserAgent(request);
471     request.setHTTPHeaderField("Cache-Control", "max-age=0");
472
473     if (newestCachedResource) {
474         const String& lastModified = newestCachedResource->response().httpHeaderField("Last-Modified");
475         const String& eTag = newestCachedResource->response().httpHeaderField("ETag");
476         if (!lastModified.isEmpty() || !eTag.isEmpty()) {
477             if (!lastModified.isEmpty())
478                 request.setHTTPHeaderField("If-Modified-Since", lastModified);
479             if (!eTag.isEmpty())
480                 request.setHTTPHeaderField("If-None-Match", eTag);
481         }
482     }
483
484     RefPtr<ResourceHandle> handle = ResourceHandle::create(m_frame->loader()->networkingContext(), request, this, false, true);
485 #if ENABLE(INSPECTOR)
486     // Because willSendRequest only gets called during redirects, we initialize
487     // the identifier and the first willSendRequest here.
488     m_currentResourceIdentifier = m_frame->page()->progress()->createUniqueIdentifier();
489     ResourceResponse redirectResponse = ResourceResponse();
490     InspectorInstrumentation::willSendRequest(m_frame, m_currentResourceIdentifier, m_frame->loader()->documentLoader(), request, redirectResponse);
491 #endif
492     return handle;
493 }
494
495 void ApplicationCacheGroup::didReceiveResponse(ResourceHandle* handle, const ResourceResponse& response)
496 {
497 #if ENABLE(INSPECTOR)
498     DocumentLoader* loader = (handle == m_manifestHandle) ? 0 : m_frame->loader()->documentLoader();
499     InspectorInstrumentationCookie cookie = InspectorInstrumentation::willReceiveResourceResponse(m_frame, m_currentResourceIdentifier, response);
500     InspectorInstrumentation::didReceiveResourceResponse(cookie, m_currentResourceIdentifier, loader, response);
501 #endif
502
503     if (handle == m_manifestHandle) {
504         didReceiveManifestResponse(response);
505         return;
506     }
507     
508     ASSERT(handle == m_currentHandle);
509
510     KURL url(handle->firstRequest().url());
511     if (url.hasFragmentIdentifier())
512         url.removeFragmentIdentifier();
513     
514     ASSERT(!m_currentResource);
515     ASSERT(m_pendingEntries.contains(url));
516     
517     unsigned type = m_pendingEntries.get(url);
518     
519     // If this is an initial cache attempt, we should not get master resources delivered here.
520     if (!m_newestCache)
521         ASSERT(!(type & ApplicationCacheResource::Master));
522
523     if (m_newestCache && response.httpStatusCode() == 304) { // Not modified.
524         ApplicationCacheResource* newestCachedResource = m_newestCache->resourceForURL(url);
525         if (newestCachedResource) {
526             m_cacheBeingUpdated->addResource(ApplicationCacheResource::create(url, newestCachedResource->response(), type, newestCachedResource->data(), newestCachedResource->path()));
527             m_pendingEntries.remove(m_currentHandle->firstRequest().url());
528             m_currentHandle->cancel();
529             m_currentHandle = 0;
530             // Load the next resource, if any.
531             startLoadingEntry();
532             return;
533         }
534         // The server could return 304 for an unconditional request - in this case, we handle the response as a normal error.
535     }
536
537     if (response.httpStatusCode() / 100 != 2 || response.url() != m_currentHandle->firstRequest().url()) {
538         if ((type & ApplicationCacheResource::Explicit) || (type & ApplicationCacheResource::Fallback)) {
539             m_frame->domWindow()->console()->addMessage(OtherMessageSource, LogMessageType, ErrorMessageLevel, "Application Cache update failed, because " + m_currentHandle->firstRequest().url().string() + 
540                 ((response.httpStatusCode() / 100 != 2) ? " could not be fetched." : " was redirected."), 0, String());
541             // Note that cacheUpdateFailed() can cause the cache group to be deleted.
542             cacheUpdateFailed();
543         } else if (response.httpStatusCode() == 404 || response.httpStatusCode() == 410) {
544             // Skip this resource. It is dropped from the cache.
545             m_currentHandle->cancel();
546             m_currentHandle = 0;
547             m_pendingEntries.remove(url);
548             // Load the next resource, if any.
549             startLoadingEntry();
550         } else {
551             // Copy the resource and its metadata from the newest application cache in cache group whose completeness flag is complete, and act
552             // as if that was the fetched resource, ignoring the resource obtained from the network.
553             ASSERT(m_newestCache);
554             ApplicationCacheResource* newestCachedResource = m_newestCache->resourceForURL(handle->firstRequest().url());
555             ASSERT(newestCachedResource);
556             m_cacheBeingUpdated->addResource(ApplicationCacheResource::create(url, newestCachedResource->response(), type, newestCachedResource->data(), newestCachedResource->path()));
557             m_pendingEntries.remove(m_currentHandle->firstRequest().url());
558             m_currentHandle->cancel();
559             m_currentHandle = 0;
560             // Load the next resource, if any.
561             startLoadingEntry();
562         }
563         return;
564     }
565     
566     m_currentResource = ApplicationCacheResource::create(url, response, type);
567 }
568
569 void ApplicationCacheGroup::didReceiveData(ResourceHandle* handle, const char* data, int length, int encodedDataLength)
570 {
571     UNUSED_PARAM(encodedDataLength);
572
573 #if ENABLE(INSPECTOR)
574     InspectorInstrumentation::didReceiveContentLength(m_frame, m_currentResourceIdentifier, length, 0);
575 #endif
576
577     if (handle == m_manifestHandle) {
578         didReceiveManifestData(data, length);
579         return;
580     }
581     
582     ASSERT(handle == m_currentHandle);
583     
584     ASSERT(m_currentResource);
585     m_currentResource->data()->append(data, length);
586
587     m_loadedSize += length;
588 }
589
590 void ApplicationCacheGroup::didFinishLoading(ResourceHandle* handle, double finishTime)
591 {
592 #if ENABLE(INSPECTOR)
593     InspectorInstrumentation::didFinishLoading(m_frame, m_frame->loader()->documentLoader(), m_currentResourceIdentifier, finishTime);
594 #endif
595
596     if (handle == m_manifestHandle) {
597         didFinishLoadingManifest();
598         return;
599     }
600
601     // After finishing the loading of any resource, we check if it will
602     // fit in our last known quota limit.
603     if (m_availableSpaceInQuota == ApplicationCacheStorage::unknownQuota()) {
604         // Failed to determine what is left in the quota. Fallback to allowing anything.
605         if (!cacheStorage().remainingSizeForOriginExcludingCache(m_origin.get(), m_newestCache.get(), m_availableSpaceInQuota))
606             m_availableSpaceInQuota = ApplicationCacheStorage::noQuota();
607     }
608
609     // Check each resource, as it loads, to see if it would fit in our
610     // idea of the available quota space.
611     if (m_availableSpaceInQuota < m_loadedSize) {
612         m_currentResource = 0;
613         cacheUpdateFailedDueToOriginQuota();
614         return;
615     }
616
617     ASSERT(m_currentHandle == handle);
618     ASSERT(m_pendingEntries.contains(handle->firstRequest().url()));
619     
620     m_pendingEntries.remove(handle->firstRequest().url());
621     
622     ASSERT(m_cacheBeingUpdated);
623
624     m_cacheBeingUpdated->addResource(m_currentResource.release());
625     m_currentHandle = 0;
626     
627     // Load the next resource, if any.
628     startLoadingEntry();
629 }
630
631 void ApplicationCacheGroup::didFail(ResourceHandle* handle, const ResourceError& error)
632 {
633 #if ENABLE(INSPECTOR)
634     InspectorInstrumentation::didFailLoading(m_frame, m_frame->loader()->documentLoader(), m_currentResourceIdentifier, error);
635 #endif
636
637     if (handle == m_manifestHandle) {
638         // A network error is logged elsewhere, no need to log again. Also, it's normal for manifest fetching to fail when working offline.
639         cacheUpdateFailed();
640         return;
641     }
642
643     ASSERT(handle == m_currentHandle);
644
645     unsigned type = m_currentResource ? m_currentResource->type() : m_pendingEntries.get(handle->firstRequest().url());
646     KURL url(handle->firstRequest().url());
647     if (url.hasFragmentIdentifier())
648         url.removeFragmentIdentifier();
649
650     ASSERT(!m_currentResource || !m_pendingEntries.contains(url));
651     m_currentResource = 0;
652     m_pendingEntries.remove(url);
653
654     if ((type & ApplicationCacheResource::Explicit) || (type & ApplicationCacheResource::Fallback)) {
655         m_frame->domWindow()->console()->addMessage(OtherMessageSource, LogMessageType, ErrorMessageLevel, "Application Cache update failed, because " + url.string() + " could not be fetched.", 0, String());
656         // Note that cacheUpdateFailed() can cause the cache group to be deleted.
657         cacheUpdateFailed();
658     } else {
659         // Copy the resource and its metadata from the newest application cache in cache group whose completeness flag is complete, and act
660         // as if that was the fetched resource, ignoring the resource obtained from the network.
661         ASSERT(m_newestCache);
662         ApplicationCacheResource* newestCachedResource = m_newestCache->resourceForURL(url);
663         ASSERT(newestCachedResource);
664         m_cacheBeingUpdated->addResource(ApplicationCacheResource::create(url, newestCachedResource->response(), type, newestCachedResource->data(), newestCachedResource->path()));
665         // Load the next resource, if any.
666         startLoadingEntry();
667     }
668 }
669
670 void ApplicationCacheGroup::didReceiveManifestResponse(const ResourceResponse& response)
671 {
672     ASSERT(!m_manifestResource);
673     ASSERT(m_manifestHandle);
674
675     if (response.httpStatusCode() == 404 || response.httpStatusCode() == 410) {
676         manifestNotFound();
677         return;
678     }
679
680     if (response.httpStatusCode() == 304)
681         return;
682
683     if (response.httpStatusCode() / 100 != 2) {
684         m_frame->domWindow()->console()->addMessage(OtherMessageSource, LogMessageType, ErrorMessageLevel, "Application Cache manifest could not be fetched.", 0, String());
685         cacheUpdateFailed();
686         return;
687     }
688
689     if (response.url() != m_manifestHandle->firstRequest().url()) {
690         m_frame->domWindow()->console()->addMessage(OtherMessageSource, LogMessageType, ErrorMessageLevel, "Application Cache manifest could not be fetched, because a redirection was attempted.", 0, String());
691         cacheUpdateFailed();
692         return;
693     }
694
695     if (!equalIgnoringCase(response.mimeType(), "text/cache-manifest")) {
696         m_frame->domWindow()->console()->addMessage(OtherMessageSource, LogMessageType, ErrorMessageLevel, "Application Cache manifest had an incorrect MIME type: " + response.mimeType() + ".", 0, String());
697         cacheUpdateFailed();
698         return;
699     }
700
701     m_manifestResource = ApplicationCacheResource::create(m_manifestHandle->firstRequest().url(), response, ApplicationCacheResource::Manifest);
702 }
703
704 void ApplicationCacheGroup::didReceiveManifestData(const char* data, int length)
705 {
706     if (m_manifestResource)
707         m_manifestResource->data()->append(data, length);
708 }
709
710 void ApplicationCacheGroup::didFinishLoadingManifest()
711 {
712     bool isUpgradeAttempt = m_newestCache;
713
714     if (!isUpgradeAttempt && !m_manifestResource) {
715         // The server returned 304 Not Modified even though we didn't send a conditional request.
716         m_frame->domWindow()->console()->addMessage(OtherMessageSource, LogMessageType, ErrorMessageLevel, "Application Cache manifest could not be fetched because of an unexpected 304 Not Modified server response.", 0, String());
717         cacheUpdateFailed();
718         return;
719     }
720
721     m_manifestHandle = 0;
722
723     // Check if the manifest was not modified.
724     if (isUpgradeAttempt) {
725         ApplicationCacheResource* newestManifest = m_newestCache->manifestResource();
726         ASSERT(newestManifest);
727     
728         if (!m_manifestResource || // The resource will be null if HTTP response was 304 Not Modified.
729             (newestManifest->data()->size() == m_manifestResource->data()->size() && !memcmp(newestManifest->data()->data(), m_manifestResource->data()->data(), newestManifest->data()->size()))) {
730
731             m_completionType = NoUpdate;
732             m_manifestResource = 0;
733             deliverDelayedMainResources();
734
735             return;
736         }
737     }
738     
739     Manifest manifest;
740     if (!parseManifest(m_manifestURL, m_manifestResource->data()->data(), m_manifestResource->data()->size(), manifest)) {
741         // At the time of this writing, lack of "CACHE MANIFEST" signature is the only reason for parseManifest to fail.
742         m_frame->domWindow()->console()->addMessage(OtherMessageSource, LogMessageType, ErrorMessageLevel, "Application Cache manifest could not be parsed. Does it start with CACHE MANIFEST?", 0, String());
743         cacheUpdateFailed();
744         return;
745     }
746
747     ASSERT(!m_cacheBeingUpdated);
748     m_cacheBeingUpdated = ApplicationCache::create();
749     m_cacheBeingUpdated->setGroup(this);
750
751     HashSet<DocumentLoader*>::const_iterator masterEnd = m_pendingMasterResourceLoaders.end();
752     for (HashSet<DocumentLoader*>::const_iterator iter = m_pendingMasterResourceLoaders.begin(); iter != masterEnd; ++iter)
753         associateDocumentLoaderWithCache(*iter, m_cacheBeingUpdated.get());
754
755     // We have the manifest, now download the resources.
756     setUpdateStatus(Downloading);
757     
758     postListenerTask(ApplicationCacheHost::DOWNLOADING_EVENT, m_associatedDocumentLoaders);
759
760     ASSERT(m_pendingEntries.isEmpty());
761
762     if (isUpgradeAttempt) {
763         ApplicationCache::ResourceMap::const_iterator end = m_newestCache->end();
764         for (ApplicationCache::ResourceMap::const_iterator it = m_newestCache->begin(); it != end; ++it) {
765             unsigned type = it->second->type();
766             if (type & ApplicationCacheResource::Master)
767                 addEntry(it->first, type);
768         }
769     }
770     
771     HashSet<String>::const_iterator end = manifest.explicitURLs.end();
772     for (HashSet<String>::const_iterator it = manifest.explicitURLs.begin(); it != end; ++it)
773         addEntry(*it, ApplicationCacheResource::Explicit);
774
775     size_t fallbackCount = manifest.fallbackURLs.size();
776     for (size_t i = 0; i  < fallbackCount; ++i)
777         addEntry(manifest.fallbackURLs[i].second, ApplicationCacheResource::Fallback);
778     
779     m_cacheBeingUpdated->setOnlineWhitelist(manifest.onlineWhitelistedURLs);
780     m_cacheBeingUpdated->setFallbackURLs(manifest.fallbackURLs);
781     m_cacheBeingUpdated->setAllowsAllNetworkRequests(manifest.allowAllNetworkRequests);
782
783     m_progressTotal = m_pendingEntries.size();
784     m_progressDone = 0;
785
786     startLoadingEntry();
787 }
788
789 void ApplicationCacheGroup::didReachMaxAppCacheSize()
790 {
791     ASSERT(m_frame);
792     ASSERT(m_cacheBeingUpdated);
793     m_frame->page()->chrome()->client()->reachedMaxAppCacheSize(cacheStorage().spaceNeeded(m_cacheBeingUpdated->estimatedSizeInStorage()));
794     m_calledReachedMaxAppCacheSize = true;
795     checkIfLoadIsComplete();
796 }
797
798 void ApplicationCacheGroup::didReachOriginQuota(PassRefPtr<Frame> frame)
799 {
800     // Inform the client the origin quota has been reached,
801     // they may decide to increase the quota.
802     frame->page()->chrome()->client()->reachedApplicationCacheOriginQuota(m_origin.get());
803 }
804
805 void ApplicationCacheGroup::cacheUpdateFailed()
806 {
807     stopLoading();
808     m_manifestResource = 0;
809
810     // Wait for master resource loads to finish.
811     m_completionType = Failure;
812     deliverDelayedMainResources();
813 }
814
815 void ApplicationCacheGroup::cacheUpdateFailedDueToOriginQuota()
816 {
817     if (!m_originQuotaReached) {
818         m_originQuotaReached = true;
819         scheduleReachedOriginQuotaCallback();
820     }
821
822     m_frame->domWindow()->console()->addMessage(OtherMessageSource, LogMessageType, ErrorMessageLevel, "Application Cache update failed, because size quota was exceeded.", 0, String());
823
824     // FIXME: Should not abort cache update - the user may choose to increase the quota.
825     cacheUpdateFailed();
826 }
827     
828 void ApplicationCacheGroup::manifestNotFound()
829 {
830     makeObsolete();
831
832     postListenerTask(ApplicationCacheHost::OBSOLETE_EVENT, m_associatedDocumentLoaders);
833     postListenerTask(ApplicationCacheHost::ERROR_EVENT, m_pendingMasterResourceLoaders);
834
835     stopLoading();
836
837     ASSERT(m_pendingEntries.isEmpty());
838     m_manifestResource = 0;
839
840     while (!m_pendingMasterResourceLoaders.isEmpty()) {
841         HashSet<DocumentLoader*>::iterator it = m_pendingMasterResourceLoaders.begin();
842         
843         ASSERT((*it)->applicationCacheHost()->candidateApplicationCacheGroup() == this);
844         ASSERT(!(*it)->applicationCacheHost()->applicationCache());
845         (*it)->applicationCacheHost()->setCandidateApplicationCacheGroup(0);
846         m_pendingMasterResourceLoaders.remove(it);
847     }
848
849     m_downloadingPendingMasterResourceLoadersCount = 0;
850     setUpdateStatus(Idle);    
851     m_frame = 0;
852     
853     if (m_caches.isEmpty()) {
854         ASSERT(m_associatedDocumentLoaders.isEmpty());
855         ASSERT(!m_cacheBeingUpdated);
856         delete this;
857     }
858 }
859
860 void ApplicationCacheGroup::checkIfLoadIsComplete()
861 {
862     if (m_manifestHandle || !m_pendingEntries.isEmpty() || m_downloadingPendingMasterResourceLoadersCount)
863         return;
864     
865     // We're done, all resources have finished downloading (successfully or not).
866
867     bool isUpgradeAttempt = m_newestCache;
868
869     switch (m_completionType) {
870     case None:
871         ASSERT_NOT_REACHED();
872         return;
873     case NoUpdate:
874         ASSERT(isUpgradeAttempt);
875         ASSERT(!m_cacheBeingUpdated);
876
877         // The storage could have been manually emptied by the user.
878         if (!m_storageID)
879             cacheStorage().storeNewestCache(this);
880
881         postListenerTask(ApplicationCacheHost::NOUPDATE_EVENT, m_associatedDocumentLoaders);
882         break;
883     case Failure:
884         ASSERT(!m_cacheBeingUpdated);
885         postListenerTask(ApplicationCacheHost::ERROR_EVENT, m_associatedDocumentLoaders);
886         if (m_caches.isEmpty()) {
887             ASSERT(m_associatedDocumentLoaders.isEmpty());
888             delete this;
889             return;
890         }
891         break;
892     case Completed: {
893         // FIXME: Fetch the resource from manifest URL again, and check whether it is identical to the one used for update (in case the application was upgraded server-side in the meanwhile). (<rdar://problem/6467625>)
894
895         ASSERT(m_cacheBeingUpdated);
896         if (m_manifestResource)
897             m_cacheBeingUpdated->setManifestResource(m_manifestResource.release());
898         else {
899             // We can get here as a result of retrying the Complete step, following
900             // a failure of the cache storage to save the newest cache due to hitting
901             // the maximum size. In such a case, m_manifestResource may be 0, as
902             // the manifest was already set on the newest cache object.
903             ASSERT(cacheStorage().isMaximumSizeReached() && m_calledReachedMaxAppCacheSize);
904         }
905
906         ApplicationCacheStorage::FailureReason failureReason;
907         RefPtr<ApplicationCache> oldNewestCache = (m_newestCache == m_cacheBeingUpdated) ? RefPtr<ApplicationCache>() : m_newestCache;
908         setNewestCache(m_cacheBeingUpdated.release());
909         if (cacheStorage().storeNewestCache(this, oldNewestCache.get(), failureReason)) {
910             // New cache stored, now remove the old cache.
911             if (oldNewestCache)
912                 cacheStorage().remove(oldNewestCache.get());
913
914             // Fire the final progress event.
915             ASSERT(m_progressDone == m_progressTotal);
916             postListenerTask(ApplicationCacheHost::PROGRESS_EVENT, m_progressTotal, m_progressDone, m_associatedDocumentLoaders);
917
918             // Fire the success event.
919             postListenerTask(isUpgradeAttempt ? ApplicationCacheHost::UPDATEREADY_EVENT : ApplicationCacheHost::CACHED_EVENT, m_associatedDocumentLoaders);
920             // It is clear that the origin quota was not reached, so clear the flag if it was set.
921             m_originQuotaReached = false;
922         } else {
923             if (failureReason == ApplicationCacheStorage::OriginQuotaReached) {
924                 // We ran out of space for this origin. Roll back to previous state.
925                 if (oldNewestCache)
926                     setNewestCache(oldNewestCache.release());
927                 cacheUpdateFailedDueToOriginQuota();
928                 return;
929             }
930
931             if (failureReason == ApplicationCacheStorage::TotalQuotaReached && !m_calledReachedMaxAppCacheSize) {
932                 // We ran out of space. All the changes in the cache storage have
933                 // been rolled back. We roll back to the previous state in here,
934                 // as well, call the chrome client asynchronously and retry to
935                 // save the new cache.
936
937                 // Save a reference to the new cache.
938                 m_cacheBeingUpdated = m_newestCache.release();
939                 if (oldNewestCache) {
940                     // Reinstate the oldNewestCache.
941                     setNewestCache(oldNewestCache.release());
942                 }
943                 scheduleReachedMaxAppCacheSizeCallback();
944                 return;
945             }
946
947             // Run the "cache failure steps"
948             // Fire the error events to all pending master entries, as well any other cache hosts
949             // currently associated with a cache in this group.
950             postListenerTask(ApplicationCacheHost::ERROR_EVENT, m_associatedDocumentLoaders);
951             // Disassociate the pending master entries from the failed new cache. Note that
952             // all other loaders in the m_associatedDocumentLoaders are still associated with
953             // some other cache in this group. They are not associated with the failed new cache.
954
955             // Need to copy loaders, because the cache group may be destroyed at the end of iteration.
956             Vector<DocumentLoader*> loaders;
957             copyToVector(m_pendingMasterResourceLoaders, loaders);
958             size_t count = loaders.size();
959             for (size_t i = 0; i != count; ++i)
960                 disassociateDocumentLoader(loaders[i]); // This can delete this group.
961
962             // Reinstate the oldNewestCache, if there was one.
963             if (oldNewestCache) {
964                 // This will discard the failed new cache.
965                 setNewestCache(oldNewestCache.release());
966             } else {
967                 // We must have been deleted by the last call to disassociateDocumentLoader().
968                 return;
969             }
970         }
971         break;
972     }
973     }
974
975     // Empty cache group's list of pending master entries.
976     m_pendingMasterResourceLoaders.clear();
977     m_completionType = None;
978     setUpdateStatus(Idle);
979     m_frame = 0;
980     m_loadedSize = 0;
981     m_availableSpaceInQuota = ApplicationCacheStorage::unknownQuota();
982     m_calledReachedMaxAppCacheSize = false;
983 }
984
985 void ApplicationCacheGroup::startLoadingEntry()
986 {
987     ASSERT(m_cacheBeingUpdated);
988
989     if (m_pendingEntries.isEmpty()) {
990         m_completionType = Completed;
991         deliverDelayedMainResources();
992         return;
993     }
994     
995     EntryMap::const_iterator it = m_pendingEntries.begin();
996
997     postListenerTask(ApplicationCacheHost::PROGRESS_EVENT, m_progressTotal, m_progressDone, m_associatedDocumentLoaders);
998     m_progressDone++;
999
1000     ASSERT(!m_currentHandle);
1001     
1002     m_currentHandle = createResourceHandle(KURL(ParsedURLString, it->first), m_newestCache ? m_newestCache->resourceForURL(it->first) : 0);
1003 }
1004
1005 void ApplicationCacheGroup::deliverDelayedMainResources()
1006 {
1007     // Need to copy loaders, because the cache group may be destroyed at the end of iteration.
1008     Vector<DocumentLoader*> loaders;
1009     copyToVector(m_pendingMasterResourceLoaders, loaders);
1010     size_t count = loaders.size();
1011     for (size_t i = 0; i != count; ++i) {
1012         DocumentLoader* loader = loaders[i];
1013         if (loader->isLoadingMainResource())
1014             continue;
1015
1016         const ResourceError& error = loader->mainDocumentError();
1017         if (error.isNull())
1018             finishedLoadingMainResource(loader);
1019         else
1020             failedLoadingMainResource(loader);
1021     }
1022     if (!count)
1023         checkIfLoadIsComplete();
1024 }
1025
1026 void ApplicationCacheGroup::addEntry(const String& url, unsigned type)
1027 {
1028     ASSERT(m_cacheBeingUpdated);
1029     ASSERT(!KURL(ParsedURLString, url).hasFragmentIdentifier());
1030     
1031     // Don't add the URL if we already have an master resource in the cache
1032     // (i.e., the main resource finished loading before the manifest).
1033     if (ApplicationCacheResource* resource = m_cacheBeingUpdated->resourceForURL(url)) {
1034         ASSERT(resource->type() & ApplicationCacheResource::Master);
1035         ASSERT(!m_frame->loader()->documentLoader()->isLoadingMainResource());
1036     
1037         resource->addType(type);
1038         return;
1039     }
1040
1041     // Don't add the URL if it's the same as the manifest URL.
1042     ASSERT(m_manifestResource);
1043     if (m_manifestResource->url() == url) {
1044         m_manifestResource->addType(type);
1045         return;
1046     }
1047     
1048     pair<EntryMap::iterator, bool> result = m_pendingEntries.add(url, type);
1049     
1050     if (!result.second)
1051         result.first->second |= type;
1052 }
1053
1054 void ApplicationCacheGroup::associateDocumentLoaderWithCache(DocumentLoader* loader, ApplicationCache* cache)
1055 {
1056     // If teardown started already, revive the group.
1057     if (!m_newestCache && !m_cacheBeingUpdated)
1058         m_newestCache = cache;
1059
1060     ASSERT(!m_isObsolete);
1061
1062     loader->applicationCacheHost()->setApplicationCache(cache);
1063
1064     ASSERT(!m_associatedDocumentLoaders.contains(loader));
1065     m_associatedDocumentLoaders.add(loader);
1066 }
1067
1068 class ChromeClientCallbackTimer: public TimerBase {
1069 public:
1070     ChromeClientCallbackTimer(ApplicationCacheGroup* cacheGroup)
1071         : m_cacheGroup(cacheGroup)
1072     {
1073     }
1074
1075 private:
1076     virtual void fired()
1077     {
1078         m_cacheGroup->didReachMaxAppCacheSize();
1079         delete this;
1080     }
1081     // Note that there is no need to use a RefPtr here. The ApplicationCacheGroup instance is guaranteed
1082     // to be alive when the timer fires since invoking the ChromeClient callback is part of its normal
1083     // update machinery and nothing can yet cause it to get deleted.
1084     ApplicationCacheGroup* m_cacheGroup;
1085 };
1086
1087 void ApplicationCacheGroup::scheduleReachedMaxAppCacheSizeCallback()
1088 {
1089     ASSERT(isMainThread());
1090     ChromeClientCallbackTimer* timer = new ChromeClientCallbackTimer(this);
1091     timer->startOneShot(0);
1092     // The timer will delete itself once it fires.
1093 }
1094
1095 void ApplicationCacheGroup::scheduleReachedOriginQuotaCallback()
1096 {
1097     // FIXME: it might be nice to run this asynchronously, because there is no return value to wait for.
1098     didReachOriginQuota(m_frame);
1099 }
1100
1101 class CallCacheListenerTask : public ScriptExecutionContext::Task {
1102 public:
1103     static PassOwnPtr<CallCacheListenerTask> create(PassRefPtr<DocumentLoader> loader, ApplicationCacheHost::EventID eventID, int progressTotal, int progressDone)
1104     {
1105         return adoptPtr(new CallCacheListenerTask(loader, eventID, progressTotal, progressDone));
1106     }
1107
1108     virtual void performTask(ScriptExecutionContext* context)
1109     {
1110         
1111         ASSERT_UNUSED(context, context->isDocument());
1112         Frame* frame = m_documentLoader->frame();
1113         if (!frame)
1114             return;
1115     
1116         ASSERT(frame->loader()->documentLoader() == m_documentLoader.get());
1117
1118         m_documentLoader->applicationCacheHost()->notifyDOMApplicationCache(m_eventID, m_progressTotal, m_progressDone);
1119     }
1120
1121 private:
1122     CallCacheListenerTask(PassRefPtr<DocumentLoader> loader, ApplicationCacheHost::EventID eventID, int progressTotal, int progressDone)
1123         : m_documentLoader(loader)
1124         , m_eventID(eventID)
1125         , m_progressTotal(progressTotal)
1126         , m_progressDone(progressDone)
1127     {
1128     }
1129
1130     RefPtr<DocumentLoader> m_documentLoader;
1131     ApplicationCacheHost::EventID m_eventID;
1132     int m_progressTotal;
1133     int m_progressDone;
1134 };
1135
1136 void ApplicationCacheGroup::postListenerTask(ApplicationCacheHost::EventID eventID, int progressTotal, int progressDone, const HashSet<DocumentLoader*>& loaderSet)
1137 {
1138     HashSet<DocumentLoader*>::const_iterator loaderSetEnd = loaderSet.end();
1139     for (HashSet<DocumentLoader*>::const_iterator iter = loaderSet.begin(); iter != loaderSetEnd; ++iter)
1140         postListenerTask(eventID, progressTotal, progressDone, *iter);
1141 }
1142
1143 void ApplicationCacheGroup::postListenerTask(ApplicationCacheHost::EventID eventID, int progressTotal, int progressDone, DocumentLoader* loader)
1144 {
1145     Frame* frame = loader->frame();
1146     if (!frame)
1147         return;
1148     
1149     ASSERT(frame->loader()->documentLoader() == loader);
1150
1151     frame->document()->postTask(CallCacheListenerTask::create(loader, eventID, progressTotal, progressDone));
1152 }
1153
1154 void ApplicationCacheGroup::setUpdateStatus(UpdateStatus status)
1155 {
1156     m_updateStatus = status;
1157     InspectorInstrumentation::updateApplicationCacheStatus(m_frame);
1158 }
1159
1160 void ApplicationCacheGroup::clearStorageID()
1161 {
1162     m_storageID = 0;
1163     
1164     HashSet<ApplicationCache*>::const_iterator end = m_caches.end();
1165     for (HashSet<ApplicationCache*>::const_iterator it = m_caches.begin(); it != end; ++it)
1166         (*it)->clearStorageID();
1167 }
1168
1169
1170 }
1171
1172 #endif // ENABLE(OFFLINE_WEB_APPLICATIONS)