Disk cache: Add a tool to upgrade a set of cache files from one version to...

net/disk_cache/backend_impl.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.
 
 // See net/disk_cache/disk_cache.h for the public interface of the cache.
 
 #ifndef NET_DISK_CACHE_BACKEND_IMPL_H__
 #define NET_DISK_CACHE_BACKEND_IMPL_H__
 
 #include "base/compiler_specific.h"
 #include "base/timer.h"
 #include "net/disk_cache/block_files.h"
 #include "net/disk_cache/disk_cache.h"
 #include "net/disk_cache/rankings.h"
 #include "net/disk_cache/stats.h"
 #include "net/disk_cache/trace.h"
 
 namespace disk_cache {
 
 // This class implements the Backend interface. An object of this
 // class handles the operations of the cache for a particular profile.
 class BackendImpl : public Backend {
  public:
   explicit BackendImpl(const std::wstring& path)
       : path_(path), block_files_(path), mask_(0), max_size_(0),
-        init_(false), restarted_(false), unit_test_(false),
+        init_(false), restarted_(false), unit_test_(false), read_only_(false),
         ALLOW_THIS_IN_INITIALIZER_LIST(factory_(this)) {}
   // mask can be used to limit the usable size of the hash table, for testing.
   BackendImpl(const std::wstring& path, uint32 mask)
       : path_(path), block_files_(path), mask_(mask), max_size_(0),
-        init_(false), restarted_(false), unit_test_(false),
+        init_(false), restarted_(false), unit_test_(false), read_only_(false),
         ALLOW_THIS_IN_INITIALIZER_LIST(factory_(this)) {}
   ~BackendImpl();
 
   // Performs general initialization for this current instance of the cache.
   bool Init();
 
   // Backend interface.
   virtual int32 GetEntryCount() const;
   virtual bool OpenEntry(const std::string& key, Entry** entry);
   virtual bool CreateEntry(const std::string& key, Entry** entry);
@@ skipping 60 matching lines @@
   // Timer callback to calculate usage statistics.
   void OnStatsTimer();
 
   // Handles the pending asynchronous IO count.
   void IncrementIoCount();
   void DecrementIoCount();
 
   // Sets internal parameters to enable unit testing mode.
   void SetUnitTestMode();
 
+  // Sets internal parameters to enable upgrade mode (for internal tools).
+  void SetUpgradeMode();
+
   // Clears the counter of references to test handling of corruptions.
   void ClearRefCountForTest();
 
   // Peforms a simple self-check, and returns the number of dirty items
   // or an error code (negative value).
   int SelfCheck();
 
+  // Same bahavior as OpenNextEntry but walks the list from back to front.
+  bool OpenPrevEntry(void** iter, Entry** prev_entry);
+
  private:
   // Creates a new backing file for the cache index.
   bool CreateBackingStore(disk_cache::File* file);
   bool InitBackingStore(bool* file_created);
   void AdjustMaxCacheSize(int table_len);
 
   // Deletes the cache and starts again.
   void RestartCache();
 
   // Creates a new entry object and checks to see if it is dirty. Returns zero
   // on success, or a disk_cache error on failure.
   int NewEntry(Addr address, EntryImpl** entry, bool* dirty);
 
   // Returns a given entry from the cache. The entry to match is determined by
   // key and hash, and the returned entry may be the matched one or it's parent
   // on the list of entries with the same hash (or bucket).
   EntryImpl* MatchEntry(const std::string& key, uint32 hash,
                          bool find_parent);
 
+  // Opens the next or previous entry on a cache iteration.
+  bool OpenFollowingEntry(bool forward, void** iter, Entry** next_entry);
+
   void DestroyInvalidEntry(Addr address, EntryImpl* entry);
 
   // Deletes entries from the cache until the current size is below the limit.
   // If empty is true, the whole cache will be trimmed, regardless of being in
   // use.
   void TrimCache(bool empty);
   
   // Handles the used storage count.
   void AddStorageSize(int32 bytes);
   void SubstractStorageSize(int32 bytes);
@@ skipping 20 matching lines @@
   BlockFiles block_files_;  // Set of files used to store all data.
   Rankings rankings_;  // Rankings to be able to trim the cache.
   uint32 mask_;  // Binary mask to map a hash to the hash table.
   int32 max_size_;  // Maximum data size for this instance.
   int num_refs_;  // Number of referenced cache entries.
   int max_refs_;  // Max number of eferenced cache entries.
   int num_pending_io_;  // Number of pending IO operations;
   bool init_;  // controls the initialization of the system.
   bool restarted_;
   bool unit_test_;
+  bool read_only_;  // Prevents updates of the rankings data (used by tools).
   bool disabled_;
 
   Stats stats_;  // Usage statistcs.
   base::RepeatingTimer<BackendImpl> timer_;  // Usage timer.
   TraceObject trace_object_;  // Inits and destroys internal tracing.
   ScopedRunnableMethodFactory<BackendImpl> factory_;
 
   DISALLOW_EVIL_CONSTRUCTORS(BackendImpl);
 };
 
 }  // namespace disk_cache
 
 #endif  // NET_DISK_CACHE_BACKEND_IMPL_H__