Disk Cache: Add more corruption tracking histograms.

net/disk_cache/rankings.h

-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// Copyright (c) 2012 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.
 
 // See net/disk_cache/disk_cache.h for the public interface.
 
 #ifndef NET_DISK_CACHE_RANKINGS_H_
 #define NET_DISK_CACHE_RANKINGS_H_
 #pragma once
 
 #include <list>
@@ skipping 127 matching lines @@
   bool SanityCheck(CacheRankingsBlock* node, bool from_list) const;
   bool DataSanityCheck(CacheRankingsBlock* node, bool from_list) const;
 
   // Sets the |contents| field of |node| to |address|.
   void SetContents(CacheRankingsBlock* node, CacheAddr address);
 
  private:
   typedef std::pair<CacheAddr, CacheRankingsBlock*> IteratorPair;
   typedef std::list<IteratorPair> IteratorList;
 
+  enum ListDirection {
+    FORWARD,
+    BACKWARD
+  };
+
   void ReadHeads();
   void ReadTails();
   void WriteHead(List list);
   void WriteTail(List list);
 
   // Gets the rankings information for a given rankings node. We may end up
   // sharing the actual memory with a loaded entry, but we are not taking a
   // reference to that entry, so |rankings| must be short lived.
   bool GetRanking(CacheRankingsBlock* rankings);
 
   // Makes |rankings| suitable to live a long life.
   void ConvertToLongLived(CacheRankingsBlock* rankings);
 
   // Finishes a list modification after a crash.
   void CompleteTransaction();
   void FinishInsert(CacheRankingsBlock* rankings);
   void RevertRemove(CacheRankingsBlock* rankings);
 
-  // Returns false if this entry will not be recognized as dirty (called during
-  // selfcheck).
-  bool CheckEntry(CacheRankingsBlock* rankings);
-
   // Returns false if node is not properly linked. This method may change the
   // provided |list| to reflect the list where this node is actually stored.
   bool CheckLinks(CacheRankingsBlock* node, CacheRankingsBlock* prev,
                   CacheRankingsBlock* next, List* list);
 
   // Checks the links between two consecutive nodes.
   bool CheckSingleLink(CacheRankingsBlock* prev, CacheRankingsBlock* next);
 
   // Peforms a simple check of the list, and returns the number of items or an
   // error code (negative value).
   int CheckList(List list);
 
+  // Walks a list in the desired direction until the nodes |end1| or |end2| are
+  // reached. Returns an error code (0 on success), the number of items verified
+  // and the addresses of the last nodes visited.
+  int CheckListSection(List list, Addr end1, Addr end2, ListDirection dir,
+                       Addr* last, Addr* second_last, int* num_items);
+
   // Returns true if addr is the head or tail of any list. When there is a
   // match |list| will contain the list number for |addr|.
   bool IsHead(CacheAddr addr, List* list) const;
   bool IsTail(CacheAddr addr, List* list) const;
 
   // Updates the iterators whenever node is being changed.
   void UpdateIterators(CacheRankingsBlock* node);
 
   // Invalidates the iterators pointing to this node.
   void InvalidateIterators(CacheRankingsBlock* node);
 
   // Keeps track of the number of entries on a list.
   void IncrementCounter(List list);
   void DecrementCounter(List list);
 
   bool init_;
   bool count_lists_;
   Addr heads_[LAST_ELEMENT];
   Addr tails_[LAST_ELEMENT];
   BackendImpl* backend_;
   LruData* control_data_;  // Data related to the LRU lists.
   IteratorList iterators_;
 
   DISALLOW_COPY_AND_ASSIGN(Rankings);
 };
 
 }  // namespace disk_cache
 
 #endif  // NET_DISK_CACHE_RANKINGS_H_