Move URL from WebCore to WTF
[WebKit-https.git] / Source / WebCore / loader / appcache / ApplicationCacheHost.h
1 /*
2  * Copyright (c) 2009, Google Inc. All rights reserved.
3  * Copyright (c) 2017 Apple Inc. All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions are
7  * met:
8  * 
9  *     * Redistributions of source code must retain the above copyright
10  * notice, this list of conditions and the following disclaimer.
11  *     * Redistributions in binary form must reproduce the above
12  * copyright notice, this list of conditions and the following disclaimer
13  * in the documentation and/or other materials provided with the
14  * distribution.
15  *     * Neither the name of Google Inc. nor the names of its
16  * contributors may be used to endorse or promote products derived from
17  * this software without specific prior written permission.
18  * 
19  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
20  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
21  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
22  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
23  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
24  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
25  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
26  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
27  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
28  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
29  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30  */
31
32 #pragma once
33
34 #include <wtf/Deque.h>
35 #include <wtf/URL.h>
36 #include <wtf/Vector.h>
37
38 namespace WebCore {
39
40 class ApplicationCache;
41 class ApplicationCacheGroup;
42 class ApplicationCacheResource;
43 class ApplicationCacheStorage;
44 class DOMApplicationCache;
45 class DocumentLoader;
46 class Frame;
47 class ResourceError;
48 class ResourceLoader;
49 class ResourceRequest;
50 class ResourceResponse;
51 class SharedBuffer;
52 class SubstituteData;
53
54 class ApplicationCacheHost {
55     WTF_MAKE_NONCOPYABLE(ApplicationCacheHost); WTF_MAKE_FAST_ALLOCATED;
56 public:
57     // The Status numeric values are specified in the HTML5 spec.
58     enum Status {
59         UNCACHED = 0,
60         IDLE = 1,
61         CHECKING = 2,
62         DOWNLOADING = 3,
63         UPDATEREADY = 4,
64         OBSOLETE = 5
65     };
66
67     struct CacheInfo {
68         URL manifest;
69         double creationTime;
70         double updateTime;
71         long long size;
72     };
73
74     struct ResourceInfo {
75         URL resource;
76         bool isMaster;
77         bool isManifest;
78         bool isFallback;
79         bool isForeign;
80         bool isExplicit;
81         long long size;
82     };
83
84     explicit ApplicationCacheHost(DocumentLoader&);
85     ~ApplicationCacheHost();
86
87     static URL createFileURL(const String&);
88
89     void selectCacheWithoutManifest();
90     void selectCacheWithManifest(const URL& manifestURL);
91
92     void maybeLoadMainResource(const ResourceRequest&, SubstituteData&);
93     void maybeLoadMainResourceForRedirect(const ResourceRequest&, SubstituteData&);
94     bool maybeLoadFallbackForMainResponse(const ResourceRequest&, const ResourceResponse&);
95     void mainResourceDataReceived(const char* data, int length, long long encodedDataLength, bool allAtOnce);
96     void finishedLoadingMainResource();
97     void failedLoadingMainResource();
98
99     WEBCORE_EXPORT bool maybeLoadResource(ResourceLoader&, const ResourceRequest&, const URL& originalURL);
100     WEBCORE_EXPORT bool maybeLoadFallbackForRedirect(ResourceLoader*, ResourceRequest&, const ResourceResponse&);
101     WEBCORE_EXPORT bool maybeLoadFallbackForResponse(ResourceLoader*, const ResourceResponse&);
102     WEBCORE_EXPORT bool maybeLoadFallbackForError(ResourceLoader*, const ResourceError&);
103
104     bool maybeLoadSynchronously(ResourceRequest&, ResourceError&, ResourceResponse&, RefPtr<SharedBuffer>&);
105     void maybeLoadFallbackSynchronously(const ResourceRequest&, ResourceError&, ResourceResponse&, RefPtr<SharedBuffer>&);
106
107     bool canCacheInPageCache();
108
109     Status status() const;
110     bool update();
111     bool swapCache();
112     void abort();
113
114     void setDOMApplicationCache(DOMApplicationCache*);
115     void notifyDOMApplicationCache(const AtomicString& eventType, int progressTotal, int progressDone);
116
117     void stopLoadingInFrame(Frame&);
118
119     void stopDeferringEvents(); // Also raises the events that have been queued up.
120
121     Vector<ResourceInfo> resourceList();
122     CacheInfo applicationCacheInfo();
123
124     bool shouldLoadResourceFromApplicationCache(const ResourceRequest&, ApplicationCacheResource*&);
125     bool getApplicationCacheFallbackResource(const ResourceRequest&, ApplicationCacheResource*&, ApplicationCache* = nullptr);
126
127 private:
128     friend class ApplicationCacheGroup;
129
130     struct DeferredEvent {
131         AtomicString eventType;
132         int progressTotal;
133         int progressDone;
134     };
135
136     bool isApplicationCacheEnabled();
137     bool isApplicationCacheBlockedForRequest(const ResourceRequest&);
138
139     void dispatchDOMEvent(const AtomicString& eventType, int progressTotal, int progressDone);
140
141     bool scheduleLoadFallbackResourceFromApplicationCache(ResourceLoader*, ApplicationCache* = nullptr);
142     void setCandidateApplicationCacheGroup(ApplicationCacheGroup*);
143     ApplicationCacheGroup* candidateApplicationCacheGroup() const { return m_candidateApplicationCacheGroup; }
144     void setApplicationCache(RefPtr<ApplicationCache>&&);
145     ApplicationCache* applicationCache() const { return m_applicationCache.get(); }
146     ApplicationCache* mainResourceApplicationCache() const { return m_mainResourceApplicationCache.get(); }
147     bool maybeLoadFallbackForMainError(const ResourceRequest&, const ResourceError&);
148
149     DOMApplicationCache* m_domApplicationCache { nullptr };
150     DocumentLoader& m_documentLoader;
151
152     bool m_defersEvents { true }; // Events are deferred until after document onload.
153     Vector<DeferredEvent> m_deferredEvents;
154
155     // The application cache that the document loader is associated with (if any).
156     RefPtr<ApplicationCache> m_applicationCache;
157
158     // Before an application cache has finished loading, this will be the candidate application
159     // group that the document loader is associated with.
160     ApplicationCacheGroup* m_candidateApplicationCacheGroup { nullptr };
161
162     // This is the application cache the main resource was loaded from (if any).
163     RefPtr<ApplicationCache> m_mainResourceApplicationCache;
164 };
165
166 }  // namespace WebCore