Port some things in browser/{download,history}, minor things in common....

chrome/common/mru_cache.h

 // Copyright (c) 2006-2008 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // This file contains a template for a Most Recently Used cache that allows
 // constant-time access to items using a key, but easy identification of the
 // least-recently-used items for removal.  Each key can only be associated with
 // one payload item at a time.
 //
 // The key object will be stored twice, so it should support efficient copying.
@@ skipping 52 matching lines @@
   }
 
   // Inserts a payload item with the given key. If an existing item has
   // the same key, it is removed prior to insertion. An iterator indicating the
   // inserted item will be returned (this will always be the front of the list).
   //
   // The payload will be copied. In the case of an OwningMRUCache, this function
   // will take ownership of the pointer.
   iterator Put(const KeyType& key, const PayloadType& payload) {
     // Remove any existing payload with that key.
-    KeyIndex::iterator index_iter = index_.find(key);
+    typename KeyIndex::iterator index_iter = index_.find(key);
     if (index_iter != index_.end()) {
       // Erase the reference to it. This will call the deletor on the removed
       // element. The index reference will be replaced in the code below.
       Erase(index_iter->second);
     } else if (max_size_ != NO_AUTO_EVICT) {
       // New item is being inserted which might make it larger than the maximum
       // size: kick the oldest thing out if necessary.
       ShrinkToSize(max_size_ - 1);
     }
 
     ordering_.push_front(value_type(key, payload));
     index_[key] = ordering_.begin();
     return ordering_.begin();
   }
 
   // Retrieves the contents of the given key, or end() if not found. This method
   // has the side effect of moving the requested item to the front of the
   // recency list.
   //
   // TODO(brettw) We may want a const version of this function in the future.
   iterator Get(const KeyType& key) {
-    KeyIndex::iterator index_iter = index_.find(key);
+    typename KeyIndex::iterator index_iter = index_.find(key);
     if (index_iter == index_.end())
       return end();
-    PayloadList::iterator iter = index_iter->second;
+    typename PayloadList::iterator iter = index_iter->second;
 
     // Move the touched item to the front of the recency ordering.
     ordering_.splice(ordering_.begin(), ordering_, iter);
     return ordering_.begin();
   }
 
   // Retrieves the payload associated with a given key and returns it via
   // result without affecting the ordering (unlike Get).
   //
   // TODO(brettw) We may want a const version of this function in the future.
   iterator Peek(const KeyType& key) {
-    KeyIndex::const_iterator index_iter = index_.find(key);
+    typename KeyIndex::const_iterator index_iter = index_.find(key);
     if (index_iter == index_.end())
       return end();
     return index_iter->second;
   }
 
   // Erases the item referenced by the given iterator. An iterator to the item
   // following it will be returned. The iterator must be valid.
   iterator Erase(iterator pos) {
     deletor_(pos->second);
     index_.erase(pos->first);
@@ skipping 62 matching lines @@
   void operator()(PayloadType& payload) {
   }
 };
 
 // A container that does not do anything to free its data. Use this when storing
 // value types (as opposed to pointers) in the list.
 template <class KeyType, class PayloadType>
 class MRUCache : public MRUCacheBase<KeyType,
                                      PayloadType,
                                      MRUCacheNullDeletor<PayloadType> > {
+ private:
+  typedef MRUCacheBase<KeyType, PayloadType,
+      MRUCacheNullDeletor<PayloadType> > ParentType;
+
  public:
   // See MRUCacheBase, noting the possibility of using NO_AUTO_EVICT.
-  MRUCache(size_type max_size) : MRUCacheBase(max_size) {
+  MRUCache(typename ParentType::size_type max_size)
+      : ParentType(max_size) {
   }
   virtual ~MRUCache() {
   }
 
  private:
-  DISALLOW_EVIL_CONSTRUCTORS(MRUCache);
+  DISALLOW_COPY_AND_ASSIGN(MRUCache);
 };
 
 // OwningMRUCache --------------------------------------------------------------
 
 template<class PayloadType>
 class MRUCachePointerDeletor {
  public:
   void operator()(PayloadType& payload) {
     delete payload;
   }
 };
 
 // A cache that owns the payload type, which must be a non-const pointer type.
 // The pointers will be deleted when they are removed, replaced, or when the
 // cache is destroyed.
 template <class KeyType, class PayloadType>
 class OwningMRUCache
     : public MRUCacheBase<KeyType,
                           PayloadType,
                           MRUCachePointerDeletor<PayloadType> > {
+ private:
+  typedef MRUCacheBase<KeyType, PayloadType,
+      MRUCachePointerDeletor<PayloadType> > ParentType;
+
  public:
   // See MRUCacheBase, noting the possibility of using NO_AUTO_EVICT.
-  OwningMRUCache(size_type max_size) : MRUCacheBase(max_size) {
+  OwningMRUCache(typename ParentType::size_type max_size)
+      : ParentType(max_size) {
   }
   virtual ~OwningMRUCache() {
   }
 
  private:
-  DISALLOW_EVIL_CONSTRUCTORS(OwningMRUCache);
+  DISALLOW_COPY_AND_ASSIGN(OwningMRUCache);
 };
 
 #endif  // CHROME_COMMON_MRU_CACHE_H__