Remove ApplicationCacheGroup::m_isCopy
[WebKit-https.git] / Source / WebCore / loader / appcache / ApplicationCacheGroup.h
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 #ifndef ApplicationCacheGroup_h
27 #define ApplicationCacheGroup_h
28
29 #include "DOMApplicationCache.h"
30 #include "URL.h"
31 #include "ResourceHandleClient.h"
32 #include <wtf/Noncopyable.h>
33 #include <wtf/HashMap.h>
34 #include <wtf/HashSet.h>
35 #include <wtf/text/WTFString.h>
36
37 namespace WebCore {
38
39 class ApplicationCache;
40 class ApplicationCacheResource;
41 class Document;
42 class DocumentLoader;
43 class Frame;
44 class ResourceHandle;
45 class SecurityOrigin;
46
47 enum ApplicationCacheUpdateOption {
48     ApplicationCacheUpdateWithBrowsingContext,
49     ApplicationCacheUpdateWithoutBrowsingContext
50 };
51
52 class ApplicationCacheGroup : ResourceHandleClient {
53     WTF_MAKE_NONCOPYABLE(ApplicationCacheGroup); WTF_MAKE_FAST_ALLOCATED;
54 public:
55     explicit ApplicationCacheGroup(const URL& manifestURL);
56     virtual ~ApplicationCacheGroup();
57     
58     enum UpdateStatus { Idle, Checking, Downloading };
59
60     static ApplicationCache* cacheForMainRequest(const ResourceRequest&, DocumentLoader*);
61     static ApplicationCache* fallbackCacheForMainRequest(const ResourceRequest&, DocumentLoader*);
62     
63     static void selectCache(Frame*, const URL& manifestURL);
64     static void selectCacheWithoutManifestURL(Frame*);
65     
66     const URL& manifestURL() const { return m_manifestURL; }
67     const SecurityOrigin* origin() const { return m_origin.get(); }
68     UpdateStatus updateStatus() const { return m_updateStatus; }
69     void setUpdateStatus(UpdateStatus status);
70
71     void setStorageID(unsigned storageID) { m_storageID = storageID; }
72     unsigned storageID() const { return m_storageID; }
73     void clearStorageID();
74     
75     void update(Frame*, ApplicationCacheUpdateOption); // FIXME: Frame should not be needed when updating without browsing context.
76     void cacheDestroyed(ApplicationCache*);
77     
78     void abort(Frame*);
79
80     bool cacheIsComplete(ApplicationCache* cache) { return m_caches.contains(cache); }
81
82     void stopLoadingInFrame(Frame*);
83
84     ApplicationCache* newestCache() const { return m_newestCache.get(); }
85     void setNewestCache(PassRefPtr<ApplicationCache>);
86
87     void makeObsolete();
88     bool isObsolete() const { return m_isObsolete; }
89
90     void finishedLoadingMainResource(DocumentLoader*);
91     void failedLoadingMainResource(DocumentLoader*);
92
93     void disassociateDocumentLoader(DocumentLoader*);
94
95 private:
96     static void postListenerTask(ApplicationCacheHost::EventID id, const HashSet<DocumentLoader*>& set) { postListenerTask(id, 0, 0, set); }
97     static void postListenerTask(ApplicationCacheHost::EventID id, DocumentLoader* loader)  { postListenerTask(id, 0, 0, loader); }
98     static void postListenerTask(ApplicationCacheHost::EventID, int progressTotal, int progressDone, const HashSet<DocumentLoader*>&);
99     static void postListenerTask(ApplicationCacheHost::EventID, int progressTotal, int progressDone, DocumentLoader*);
100
101     void scheduleReachedMaxAppCacheSizeCallback();
102
103     PassRefPtr<ResourceHandle> createResourceHandle(const URL&, ApplicationCacheResource* newestCachedResource);
104
105     // For normal resource loading, WebKit client is asked about each resource individually. Since application cache does not belong to any particular document,
106     // the existing client callback cannot be used, so assume that any client that enables application cache also wants it to use credential storage.
107     virtual bool shouldUseCredentialStorage(ResourceHandle*) override { return true; }
108
109     virtual void didReceiveResponse(ResourceHandle*, const ResourceResponse&) override;
110     virtual void didReceiveData(ResourceHandle*, const char*, unsigned length, int encodedDataLength) override;
111     virtual void didFinishLoading(ResourceHandle*, double finishTime) override;
112     virtual void didFail(ResourceHandle*, const ResourceError&) override;
113
114     void didReceiveManifestResponse(const ResourceResponse&);
115     void didReceiveManifestData(const char*, int);
116     void didFinishLoadingManifest();
117     void didReachMaxAppCacheSize();
118     void didReachOriginQuota(int64_t totalSpaceNeeded);
119     
120     void startLoadingEntry();
121     void deliverDelayedMainResources();
122     void checkIfLoadIsComplete();
123     void cacheUpdateFailed();
124     void recalculateAvailableSpaceInQuota();
125     void manifestNotFound();
126     
127     void addEntry(const String&, unsigned type);
128     
129     void associateDocumentLoaderWithCache(DocumentLoader*, ApplicationCache*);
130     
131     void stopLoading();
132     
133     URL m_manifestURL;
134     RefPtr<SecurityOrigin> m_origin;
135     UpdateStatus m_updateStatus;
136     
137     // This is the newest complete cache in the group.
138     RefPtr<ApplicationCache> m_newestCache;
139     
140     // All complete caches in this cache group.
141     HashSet<ApplicationCache*> m_caches;
142     
143     // The cache being updated (if any). Note that cache updating does not immediately create a new
144     // ApplicationCache object, so this may be null even when update status is not Idle.
145     RefPtr<ApplicationCache> m_cacheBeingUpdated;
146
147     // List of pending master entries, used during the update process to ensure that new master entries are cached.
148     HashSet<DocumentLoader*> m_pendingMasterResourceLoaders;
149     // How many of the above pending master entries have not yet finished downloading.
150     int m_downloadingPendingMasterResourceLoadersCount;
151     
152     // These are all the document loaders that are associated with a cache in this group.
153     HashSet<DocumentLoader*> m_associatedDocumentLoaders;
154
155     // The URLs and types of pending cache entries.
156     typedef HashMap<String, unsigned> EntryMap;
157     EntryMap m_pendingEntries;
158     
159     // The total number of items to be processed to update the cache group and the number that have been done.
160     int m_progressTotal;
161     int m_progressDone;
162
163     // Frame used for fetching resources when updating.
164     // 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.
165     Frame* m_frame;
166   
167     // An obsolete cache group is never stored, but the opposite is not true - storing may fail for multiple reasons, such as exceeding disk quota.
168     unsigned m_storageID;
169     bool m_isObsolete;
170
171     // During update, this is used to handle asynchronously arriving results.
172     enum CompletionType {
173         None,
174         NoUpdate,
175         Failure,
176         Completed
177     };
178     CompletionType m_completionType;
179
180     // This flag is set immediately after the ChromeClient::reachedMaxAppCacheSize() callback is invoked as a result of the storage layer failing to save a cache
181     // due to reaching the maximum size of the application cache database file. This flag is used by ApplicationCacheGroup::checkIfLoadIsComplete() to decide
182     // the course of action in case of this failure (i.e. call the ChromeClient callback or run the failure steps).
183     bool m_calledReachedMaxAppCacheSize;
184     
185     RefPtr<ResourceHandle> m_currentHandle;
186     RefPtr<ApplicationCacheResource> m_currentResource;
187     unsigned long m_currentResourceIdentifier;
188
189     RefPtr<ApplicationCacheResource> m_manifestResource;
190     RefPtr<ResourceHandle> m_manifestHandle;
191
192     int64_t m_availableSpaceInQuota;
193     bool m_originQuotaExceededPreviously;
194
195     friend class ChromeClientCallbackTimer;
196 };
197
198 } // namespace WebCore
199
200 #endif // ApplicationCacheGroup_h