fb60dca84c05ddbbcf7cef91f159db37c1bd83f8
[WebKit-https.git] / WebCore / loader / appcache / ApplicationCacheGroup.h
1 /*
2  * Copyright (C) 2008 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 #if ENABLE(OFFLINE_WEB_APPLICATIONS)
30
31 #include <wtf/Noncopyable.h>
32 #include <wtf/HashMap.h>
33 #include <wtf/HashSet.h>
34
35 #include "KURL.h"
36 #include "PlatformString.h"
37 #include "ResourceHandle.h"
38 #include "ResourceHandleClient.h"
39 #include "SharedBuffer.h"
40
41 namespace WebCore {
42
43 class ApplicationCache;
44 class ApplicationCacheResource;
45 class DOMApplicationCache;
46 class Document;
47 class DocumentLoader;
48 class Frame;
49
50 class ApplicationCacheGroup : Noncopyable, ResourceHandleClient {
51 public:
52     ApplicationCacheGroup(const KURL& manifestURL);    
53     ~ApplicationCacheGroup();
54     
55     enum Status { Idle, Checking, Downloading };
56
57     static ApplicationCache* cacheForMainRequest(const ResourceRequest&, DocumentLoader*);
58     
59     static void selectCache(Frame*, const KURL& manifestURL);
60     static void selectCacheWithoutManifestURL(Frame*);
61     
62     const KURL& manifestURL() const { return m_manifestURL; }
63     Status status() const { return m_status; }
64     
65     void setStorageID(unsigned storageID) { m_storageID = storageID; }
66     unsigned storageID() const { return m_storageID; }
67     void clearStorageID();
68     
69     void update(Frame*);
70     void cacheDestroyed(ApplicationCache*);
71         
72     ApplicationCache* newestCache() const { return m_newestCache.get(); }
73
74     void finishedLoadingMainResource(DocumentLoader* loader);
75     void documentLoaderDestroyed(DocumentLoader* loader);
76
77     void setNewestCache(PassRefPtr<ApplicationCache> newestCache);
78
79 private:
80     typedef void (DOMApplicationCache::*ListenerFunction)();
81     void callListenersOnAssociatedDocuments(ListenerFunction);
82     void callListeners(ListenerFunction, const Vector<RefPtr<DocumentLoader> >& loaders);
83     
84     virtual void didReceiveResponse(ResourceHandle*, const ResourceResponse&);
85     virtual void didReceiveData(ResourceHandle*, const char*, int, int lengthReceived);
86     virtual void didFinishLoading(ResourceHandle*);
87     virtual void didFail(ResourceHandle*, const ResourceError&);
88
89     void didReceiveManifestResponse(const ResourceResponse&);
90     void didReceiveManifestData(const char*, int);
91     void didFinishLoadingManifest();
92     void didFailToLoadManifest();
93     
94     void startLoadingEntry();
95     void checkIfLoadIsComplete();
96     void cacheUpdateFailed();
97     
98     void addEntry(const String&, unsigned type);
99     
100     void associateDocumentLoaderWithCache(DocumentLoader*, ApplicationCache*);
101     
102     KURL m_manifestURL;
103     Status m_status;
104     
105     // This is the newest cache in the group.
106     RefPtr<ApplicationCache> m_newestCache;
107     
108     // During tear-down we save the pointer to the newest cache to prevent reference cycles.
109     ApplicationCache* m_savedNewestCachePointer;
110     
111     // The caches in this cache group.
112     HashSet<ApplicationCache*> m_caches;
113     
114     // The cache being updated (if any).
115     RefPtr<ApplicationCache> m_cacheBeingUpdated;
116
117     // When a cache group does not yet have a complete cache, this contains the document loaders
118     // that should be associated with the cache once it has been downloaded.
119     HashSet<DocumentLoader*> m_cacheCandidates;
120     
121     // These are all the document loaders that are associated with a cache in this group.
122     HashSet<DocumentLoader*> m_associatedDocumentLoaders;
123     
124     // The URLs and types of pending cache entries.
125     typedef HashMap<String, unsigned> EntryMap;
126     EntryMap m_pendingEntries;
127
128     // Frame used for fetching resources when updating
129     Frame* m_frame;
130   
131     unsigned m_storageID;
132     
133     RefPtr<ResourceHandle> m_currentHandle;
134     RefPtr<ApplicationCacheResource> m_currentResource;
135     
136     RefPtr<ApplicationCacheResource> m_manifestResource;
137     RefPtr<ResourceHandle> m_manifestHandle;
138 };
139
140 } // namespace WebCore
141
142 #endif // ENABLE(OFFLINE_WEB_APPLICATIONS)
143
144 #endif // ApplicationCacheGroup_h