9590b6a17d3e994701a2005245e08202d15acb82
[WebKit-https.git] / WebCore / loader / CachedResource.h
1 /*
2     This file is part of the KDE libraries
3
4     Copyright (C) 1998 Lars Knoll (knoll@mpi-hd.mpg.de)
5     Copyright (C) 2001 Dirk Mueller <mueller@kde.org>
6     Copyright (C) 2006 Samuel Weinig (sam.weinig@gmail.com)
7     Copyright (C) 2004, 2005, 2006 Apple Computer, Inc.
8
9     This library is free software; you can redistribute it and/or
10     modify it under the terms of the GNU Library General Public
11     License as published by the Free Software Foundation; either
12     version 2 of the License, or (at your option) any later version.
13
14     This library is distributed in the hope that it will be useful,
15     but WITHOUT ANY WARRANTY; without even the implied warranty of
16     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
17     Library General Public License for more details.
18
19     You should have received a copy of the GNU Library General Public License
20     along with this library; see the file COPYING.LIB.  If not, write to
21     the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
22     Boston, MA 02111-1307, USA.
23
24     This class provides all functionality needed for loading images, style sheets and html
25     pages from the web. It has a memory cache for these objects.
26 */
27
28 #ifndef CachedResource_h
29 #define CachedResource_h
30
31 #include "CachePolicy.h"
32 #include "PlatformString.h"
33 #include "ResourceLoaderClient.h" // defines PlatformResponse and PlatformData
34 #include <wtf/HashSet.h>
35 #include <wtf/Vector.h>
36 #include <time.h>
37
38 namespace WebCore {
39     class CachedResourceClient;
40     class Request;
41     
42     /**
43      *
44      * A cached object. Classes who want to use this object should derive
45      * from CachedResourceClient, to get the function calls in case the requested data has arrived.
46      *
47      * This class also does the actual communication with kio and loads the file.
48      */
49     class CachedResource {
50     public:
51         enum Type {
52             ImageResource,
53             CSSStyleSheet,
54             Script
55 #ifdef XSLT_SUPPORT
56             , XSLStyleSheet
57 #endif
58 #ifdef XBL_SUPPORT
59             , XBL
60 #endif
61         };
62
63         enum Status {
64             NotCached,    // this URL is not cached
65             Unknown,      // let cache decide what to do with it
66             New,          // inserting new item
67             Pending,      // only partially loaded
68             Persistent,   // never delete this
69             Cached,       // regular case
70             Uncacheable   // too big to be cached, will be destroyed as soon as possible
71         };
72
73         CachedResource(const String& URL, Type type, CachePolicy cachePolicy, time_t expireDate, int size = 0)
74         {
75             m_url = URL;
76             m_type = type;
77             m_status = Pending;
78             m_size = size;
79             m_free = false;
80             m_cachePolicy = cachePolicy;
81             m_request = 0;
82             m_response = 0;
83             m_allData = 0;
84             m_expireDate = expireDate;
85             m_deleted = false;
86             m_expireDateChanged = false;
87             
88             m_accessCount = 0;
89             
90             m_nextInLRUList = 0;
91             m_prevInLRUList = 0;
92         }
93         virtual ~CachedResource();
94
95         virtual void setCharset(const String&) { }
96         virtual Vector<char>& bufferData(const char* bytes, int addedSize, Request*);
97         virtual void data(Vector<char>&, bool allDataReceived) = 0;
98         virtual void error() = 0;
99
100         const String &url() const { return m_url; }
101         Type type() const { return m_type; }
102
103         virtual void ref(CachedResourceClient*);
104         virtual void deref(CachedResourceClient*);
105
106         int count() const { return m_clients.size(); }
107
108         Status status() const { return m_status; }
109
110         int size() const { return m_size; }
111
112         bool isLoaded() const { return !m_loading; }
113
114         virtual bool isImage() const { return false; }
115
116         int accessCount() const { return m_accessCount; }
117         void increaseAccessCount() { m_accessCount++; }
118     
119         /**
120          * computes the status of an object after loading.
121          * the result depends on the objects size and the size of the cache
122          * also updates the expire date on the cache entry file
123          */
124         void finish();
125
126         /**
127          * Called by the cache if the object has been removed from the cache dict
128          * while still being referenced. This means the object should kill itself
129          * if its reference counter drops down to zero.
130          */
131         void setFree(bool b) { m_free = b; }
132
133         CachePolicy cachePolicy() const { return m_cachePolicy; }
134
135         void setRequest(Request*);
136
137         PlatformResponse response() const { return m_response; }
138         void setResponse(PlatformResponse);
139         PlatformData allData() const { return m_allData; }
140         void setAllData(PlatformData);
141
142         bool canDelete() const { return m_clients.isEmpty() && !m_request; }
143
144         void setExpireDate(time_t expireDate, bool changeHttpCache);
145
146         bool isExpired() const;
147
148         virtual bool schedule() const { return false; }
149
150         // List of acceptable MIME types seperated by ",".
151         // A MIME type may contain a wildcard, e.g. "text/*".
152         String accept() const { return m_accept; }
153         void setAccept(const String& accept) { m_accept = accept; }
154
155     protected:
156         void setSize(int size);
157
158         HashSet<CachedResourceClient*> m_clients;
159
160         String m_url;
161         String m_accept;
162         Request* m_request;
163
164         PlatformResponse m_response;
165         PlatformData m_allData;
166
167         Type m_type;
168         Status m_status;
169
170     private:
171         int m_size;
172         int m_accessCount;
173     
174     protected:
175         time_t m_expireDate;
176         CachePolicy m_cachePolicy;
177         bool m_free : 1;
178         bool m_deleted : 1;
179         bool m_loading : 1;
180         bool m_expireDateChanged : 1;
181
182     private:
183         bool allowInLRUList() const { return canDelete() && status() != Persistent; }
184
185         CachedResource* m_nextInLRUList;
186         CachedResource* m_prevInLRUList;
187         friend class Cache;
188     };
189
190 }
191
192 #endif