diff -r 000000000000 -r 4f2f89ce4247 WebCore/loader/appcache/ApplicationCacheGroup.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/WebCore/loader/appcache/ApplicationCacheGroup.h Fri Sep 17 09:02:29 2010 +0300 @@ -0,0 +1,204 @@ +/* + * Copyright (C) 2008, 2009 Apple Inc. All Rights Reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY + * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef ApplicationCacheGroup_h +#define ApplicationCacheGroup_h + +#if ENABLE(OFFLINE_WEB_APPLICATIONS) + +#include +#include +#include + +#include "DOMApplicationCache.h" +#include "KURL.h" +#include "PlatformString.h" +#include "ResourceHandle.h" +#include "ResourceHandleClient.h" +#include "SharedBuffer.h" + +namespace WebCore { + +class ApplicationCache; +class ApplicationCacheResource; +class Document; +class DocumentLoader; +class Frame; + +enum ApplicationCacheUpdateOption { + ApplicationCacheUpdateWithBrowsingContext, + ApplicationCacheUpdateWithoutBrowsingContext +}; + +class ApplicationCacheGroup : public Noncopyable, ResourceHandleClient { +public: + ApplicationCacheGroup(const KURL& manifestURL, bool isCopy = false); + ~ApplicationCacheGroup(); + + enum UpdateStatus { Idle, Checking, Downloading }; + + static ApplicationCache* cacheForMainRequest(const ResourceRequest&, DocumentLoader*); + static ApplicationCache* fallbackCacheForMainRequest(const ResourceRequest&, DocumentLoader*); + + static void selectCache(Frame*, const KURL& manifestURL); + static void selectCacheWithoutManifestURL(Frame*); + + const KURL& manifestURL() const { return m_manifestURL; } + UpdateStatus updateStatus() const { return m_updateStatus; } + void setUpdateStatus(UpdateStatus status); + + void setStorageID(unsigned storageID) { m_storageID = storageID; } + unsigned storageID() const { return m_storageID; } + void clearStorageID(); + + void update(Frame*, ApplicationCacheUpdateOption); // FIXME: Frame should not be needed when updating without browsing context. + void cacheDestroyed(ApplicationCache*); + + bool cacheIsBeingUpdated(const ApplicationCache* cache) const { return cache == m_cacheBeingUpdated; } + + ApplicationCache* newestCache() const { return m_newestCache.get(); } + void setNewestCache(PassRefPtr); + + void makeObsolete(); + bool isObsolete() const { return m_isObsolete; } + + void finishedLoadingMainResource(DocumentLoader*); + void failedLoadingMainResource(DocumentLoader*); + + void disassociateDocumentLoader(DocumentLoader*); + + bool isCopy() const { return m_isCopy; } + +private: + static void postListenerTask(ApplicationCacheHost::EventID id, const HashSet& set) { postListenerTask(id, 0, 0, set); } + static void postListenerTask(ApplicationCacheHost::EventID id, DocumentLoader* loader) { postListenerTask(id, 0, 0, loader); } + static void postListenerTask(ApplicationCacheHost::EventID, int progressTotal, int progressDone, const HashSet&); + static void postListenerTask(ApplicationCacheHost::EventID, int progressTotal, int progressDone, DocumentLoader*); + + void scheduleReachedMaxAppCacheSizeCallback(); + + PassRefPtr createResourceHandle(const KURL&, ApplicationCacheResource* newestCachedResource); + + // For normal resource loading, WebKit client is asked about each resource individually. Since application cache does not belong to any particular document, + // the existing client callback cannot be used, so assume that any client that enables application cache also wants it to use credential storage. + virtual bool shouldUseCredentialStorage(ResourceHandle*) { return true; } + +#if ENABLE(INSPECTOR) + virtual void willSendRequest(ResourceHandle*, ResourceRequest&, const ResourceResponse&); +#endif + virtual void didReceiveResponse(ResourceHandle*, const ResourceResponse&); + virtual void didReceiveData(ResourceHandle*, const char*, int length, int lengthReceived); + virtual void didFinishLoading(ResourceHandle*); + virtual void didFail(ResourceHandle*, const ResourceError&); + + void didReceiveManifestResponse(const ResourceResponse&); + void didReceiveManifestData(const char*, int); + void didFinishLoadingManifest(); + void didReachMaxAppCacheSize(); + + void startLoadingEntry(); + void deliverDelayedMainResources(); + void checkIfLoadIsComplete(); + void cacheUpdateFailed(); + void manifestNotFound(); + + void addEntry(const String&, unsigned type); + + void associateDocumentLoaderWithCache(DocumentLoader*, ApplicationCache*); + + void stopLoading(); + + KURL m_manifestURL; + UpdateStatus m_updateStatus; + + // This is the newest complete cache in the group. + RefPtr m_newestCache; + + // All complete caches in this cache group. + HashSet m_caches; + + // The cache being updated (if any). Note that cache updating does not immediately create a new + // ApplicationCache object, so this may be null even when update status is not Idle. + RefPtr m_cacheBeingUpdated; + + // List of pending master entries, used during the update process to ensure that new master entries are cached. + HashSet m_pendingMasterResourceLoaders; + // How many of the above pending master entries have not yet finished downloading. + int m_downloadingPendingMasterResourceLoadersCount; + + // These are all the document loaders that are associated with a cache in this group. + HashSet m_associatedDocumentLoaders; + + // The URLs and types of pending cache entries. + typedef HashMap EntryMap; + EntryMap m_pendingEntries; + + // The total number of items to be processed to update the cache group and the number that have been done. + int m_progressTotal; + int m_progressDone; + + // Frame used for fetching resources when updating. + // FIXME: An update started by a particular frame should not stop if it is destroyed, but there are other frames associated with the same cache group. + Frame* m_frame; + + // An obsolete cache group is never stored, but the opposite is not true - storing may fail for multiple reasons, such as exceeding disk quota. + unsigned m_storageID; + bool m_isObsolete; + + // During update, this is used to handle asynchronously arriving results. + enum CompletionType { + None, + NoUpdate, + Failure, + Completed + }; + CompletionType m_completionType; + + // Whether this cache group is a copy that's only used for transferring the cache to another file. + bool m_isCopy; + + // This flag is set immediately after the ChromeClient::reachedMaxAppCacheSize() callback is invoked as a result of the storage layer failing to save a cache + // due to reaching the maximum size of the application cache database file. This flag is used by ApplicationCacheGroup::checkIfLoadIsComplete() to decide + // the course of action in case of this failure (i.e. call the ChromeClient callback or run the failure steps). + bool m_calledReachedMaxAppCacheSize; + + RefPtr m_currentHandle; + RefPtr m_currentResource; + +#if ENABLE(INSPECTOR) + unsigned long m_currentResourceIdentifier; +#endif + + RefPtr m_manifestResource; + RefPtr m_manifestHandle; + + friend class ChromeClientCallbackTimer; +}; + +} // namespace WebCore + +#endif // ENABLE(OFFLINE_WEB_APPLICATIONS) + +#endif // ApplicationCacheGroup_h