Index: django/core/cache/__init__.py
===================================================================
--- django/core/cache/__init__.py	(revision 6803)
+++ django/core/cache/__init__.py	(working copy)
@@ -22,19 +22,28 @@
 BACKENDS = {
     # name for use in settings file --> name of module in "backends" directory
     'memcached': 'memcached',
-    'simple': 'simple',
     'locmem': 'locmem',
     'file': 'filebased',
     'db': 'db',
     'dummy': 'dummy',
 }
 
+DEPRECATED_BACKENDS = {
+    # deprecated backend --> replacement module
+    'simple': 'locmem',
+}
+
 def get_cache(backend_uri):
     if backend_uri.find(':') == -1:
         raise InvalidCacheBackendError, "Backend URI must start with scheme://"
     scheme, rest = backend_uri.split(':', 1)
     if not rest.startswith('//'):
         raise InvalidCacheBackendError, "Backend URI must start with scheme://"
+    if scheme in DEPRECATED_BACKENDS:
+        import warnings
+        warnings.warn("'%s' backend is deprecated. Use '%s' instead." % 
+            (scheme, DEPRECATED_BACKENDS[scheme]), DeprecationWarning)
+        scheme = DEPRECATED_BACKENDS[scheme]
     if scheme not in BACKENDS:
         raise InvalidCacheBackendError, "%r is not a valid cache backend" % scheme
 
Index: django/core/cache/backends/locmem.py
===================================================================
--- django/core/cache/backends/locmem.py	(revision 6803)
+++ django/core/cache/backends/locmem.py	(working copy)
@@ -6,20 +6,44 @@
 except ImportError:
     import pickle
 
-from django.core.cache.backends.simple import CacheClass as SimpleCacheClass
+from django.core.cache.backends.base import BaseCache
 from django.utils.synch import RWLock
 
-class CacheClass(SimpleCacheClass):
-    def __init__(self, host, params):
-        SimpleCacheClass.__init__(self, host, params)
+class CacheClass(BaseCache):
+    def __init__(self, _, params):
+        BaseCache.__init__(self, params)
+        self._cache = {}
+        self._expire_info = {}
+
+        max_entries = params.get('max_entries', 300)
+        try:
+            self._max_entries = int(max_entries)
+        except (ValueError, TypeError):
+            self._max_entries = 300
+
+        cull_frequency = params.get('cull_frequency', 3)
+        try:
+            self._cull_frequency = int(cull_frequency)
+        except (ValueError, TypeError):
+            self._cull_frequency = 3
+
         self._lock = RWLock()
 
+    def _add(self, key, value, timeout=None):
+        if len(self._cache) >= self._max_entries:
+            self._cull()
+        if timeout is None:
+            timeout = self.default_timeout
+        if key not in self._cache.keys():
+            self._cache[key] = value
+            self._expire_info[key] = time.time() + timeout
+
     def add(self, key, value, timeout=None):
         self._lock.writer_enters()
         # Python 2.3 and 2.4 don't allow combined try-except-finally blocks.
         try:
             try:
-                super(CacheClass, self).add(key, pickle.dumps(value), timeout)
+                self._add(key, pickle.dumps(value), timeout)
             except pickle.PickleError:
                 pass
         finally:
@@ -51,20 +75,50 @@
             finally:
                 self._lock.writer_leaves()
 
+    def _set(self, key, value, timeout=None):
+        if len(self._cache) >= self._max_entries:
+            self._cull()
+        if timeout is None:
+            timeout = self.default_timeout
+        self._cache[key] = value
+        self._expire_info[key] = time.time() + timeout
+
     def set(self, key, value, timeout=None):
         self._lock.writer_enters()
         # Python 2.3 and 2.4 don't allow combined try-except-finally blocks.
         try:
             try:
-                super(CacheClass, self).set(key, pickle.dumps(value), timeout)
+                self._set(key, pickle.dumps(value), timeout)
             except pickle.PickleError:
                 pass
         finally:
             self._lock.writer_leaves()
 
+    def has_key(self, key):
+        return key in self._cache
+
+    def _cull(self):
+        if self._cull_frequency == 0:
+            self._cache.clear()
+            self._expire_info.clear()
+        else:
+            doomed = [k for (i, k) in enumerate(self._cache) if i % self._cull_frequency == 0]
+            for k in doomed:
+                self.delete(k)
+
+    def _delete(self, key):
+        try:
+            del self._cache[key]
+        except KeyError:
+            pass
+        try:
+            del self._expire_info[key]
+        except KeyError:
+            pass
+
     def delete(self, key):
         self._lock.writer_enters()
         try:
-            SimpleCacheClass.delete(self, key)
+            self._delete(key)
         finally:
             self._lock.writer_leaves()
Index: django/core/cache/backends/filebased.py
===================================================================
--- django/core/cache/backends/filebased.py	(revision 6803)
+++ django/core/cache/backends/filebased.py	(working copy)
@@ -1,21 +1,32 @@
 "File-based cache backend"
 
-from django.core.cache.backends.simple import CacheClass as SimpleCacheClass
-from django.utils.http import urlquote_plus
 import os, time
 try:
     import cPickle as pickle
 except ImportError:
     import pickle
+from django.core.cache.backends.base import BaseCache
+from django.utils.http import urlquote_plus
 
-class CacheClass(SimpleCacheClass):
+class CacheClass(BaseCache):
     def __init__(self, dir, params):
+        BaseCache.__init__(self, params)
+        
+        max_entries = params.get('max_entries', 300)
+        try:
+            self._max_entries = int(max_entries)
+        except (ValueError, TypeError):
+            self._max_entries = 300
+            
+        cull_frequency = params.get('cull_frequency', 3)
+        try:
+            self._cull_frequency = int(cull_frequency)
+        except (ValueError, TypeError):
+            self._cull_frequency = 3
+            
         self._dir = dir
         if not os.path.exists(self._dir):
             self._createdir()
-        SimpleCacheClass.__init__(self, dir, params)
-        del self._cache
-        del self._expire_info
 
     def add(self, key, value, timeout=None):
         fname = self._key_to_file(key)