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 #if !PLATFORM(QT)
  83             m_response = 0;
  84 #endif
  85             m_allData = 0;
  86             m_expireDate = expireDate;
  87             m_deleted = false;
  88             m_expireDateChanged = false;
  89
  90             m_accessCount = 0;
  91
  92             m_nextInLRUList = 0;
  93             m_prevInLRUList = 0;
  94         }
  95         virtual ~CachedResource();
  96
  97         virtual void setCharset(const String&) { }
  98         virtual Vector<char>& bufferData(const char* bytes, int addedSize, Request*);
  99         virtual void data(Vector<char>&, bool allDataReceived) = 0;
 100         virtual void error() = 0;
 101
 102         const String &url() const { return m_url; }
 103         Type type() const { return m_type; }
 104
 105         virtual void ref(CachedResourceClient*);
 106         virtual void deref(CachedResourceClient*);
 107
 108         int count() const { return m_clients.size(); }
 109
 110         Status status() const { return m_status; }
 111
 112         int size() const { return m_size; }
 113
 114         bool isLoaded() const { return !m_loading; }
 115
 116         virtual bool isImage() const { return false; }
 117
 118         int accessCount() const { return m_accessCount; }
 119         void increaseAccessCount() { m_accessCount++; }
 120
 121         /**
 122          * computes the status of an object after loading.
 123          * the result depends on the objects size and the size of the cache
 124          * also updates the expire date on the cache entry file
 125          */
 126         void finish();
 127
 128         /**
 129          * Called by the cache if the object has been removed from the cache dict
 130          * while still being referenced. This means the object should kill itself
 131          * if its reference counter drops down to zero.
 132          */
 133         void setFree(bool b) { m_free = b; }
 134
 135         CachePolicy cachePolicy() const { return m_cachePolicy; }
 136
 137         void setRequest(Request*);
 138
 139         PlatformResponse response() const { return m_response; }
 140         void setResponse(PlatformResponse);
 141         PlatformData allData() const { return m_allData; }
 142         void setAllData(PlatformData);
 143
 144         bool canDelete() const { return m_clients.isEmpty() && !m_request; }
 145
 146         void setExpireDate(time_t expireDate, bool changeHttpCache);
 147
 148         bool isExpired() const;
 149
 150         virtual bool schedule() const { return false; }
 151
 152         // List of acceptable MIME types seperated by ",".
 153         // A MIME type may contain a wildcard, e.g. "text/*".
 154         String accept() const { return m_accept; }
 155         void setAccept(const String& accept) { m_accept = accept; }
 156
 157     protected:
 158         void setSize(int size);
 159
 160         HashSet<CachedResourceClient*> m_clients;
 161
 162         String m_url;
 163         String m_accept;
 164         Request* m_request;
 165
 166         PlatformResponse m_response;
 167         PlatformData m_allData;
 168
 169         Type m_type;
 170         Status m_status;
 171
 172     private:
 173         int m_size;
 174         int m_accessCount;
 175
 176     protected:
 177         time_t m_expireDate;
 178         CachePolicy m_cachePolicy;
 179         bool m_free : 1;
 180         bool m_deleted : 1;
 181         bool m_loading : 1;
 182         bool m_expireDateChanged : 1;
 183
 184     private:
 185         bool allowInLRUList() const { return canDelete() && status() != Persistent; }
 186
 187         CachedResource* m_nextInLRUList;
 188         CachedResource* m_prevInLRUList;
 189         friend class Cache;
 190     };
 191
 192 }
 193
 194 #endif