Add an IO thread index bitmap to disk cache.

net/disk_cache/backend_impl.h

 // 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 of the cache.
 
 #ifndef NET_DISK_CACHE_BACKEND_IMPL_H_
 #define NET_DISK_CACHE_BACKEND_IMPL_H_
 
 #include "base/file_path.h"
 #include "base/hash_tables.h"
+#include "base/memory/ref_counted.h"
+#include "base/message_loop_proxy.h"
 #include "base/timer.h"
+#include "net/disk_cache/bitmap.h"
 #include "net/disk_cache/block_files.h"
 #include "net/disk_cache/disk_cache.h"
 #include "net/disk_cache/eviction.h"
 #include "net/disk_cache/in_flight_backend_io.h"
 #include "net/disk_cache/rankings.h"
 #include "net/disk_cache/stats.h"
 #include "net/disk_cache/stress_support.h"
 #include "net/disk_cache/trace.h"
 
 namespace net {
@@ skipping 30 matching lines @@
   // CreateCacheBackend().
   static int CreateBackend(const base::FilePath& full_path, bool force,
                            int max_bytes, net::CacheType type,
                            uint32 flags, base::MessageLoopProxy* thread,
                            net::NetLog* net_log, Backend** backend,
                            const CompletionCallback& callback);
 
   // Performs general initialization for this current instance of the cache.
   int Init(const CompletionCallback& callback);
 
-  // Performs the actual initialization and final cleanup on destruction.
+  // Performs the actual initialization and final cleanup on destruction. If
+  // |async_thread| is non null, then |bitmap_| may be initialized on that

[rvargas (doing something else), 2013/02/12 01:58:33]

I'm guessing the comment is stale now.

+  // thread, otherwise |bitmap_| is left unchanged.
   int SyncInit();
   void CleanupCache();
 
   // Same behavior as OpenNextEntry but walks the list from back to front.
   int OpenPrevEntry(void** iter, Entry** prev_entry,
                     const CompletionCallback& callback);
 
   // Synchronous implementation of the asynchronous interface.
   int SyncOpenEntry(const std::string& key, Entry** entry);
   int SyncCreateEntry(const std::string& key, Entry** entry);
@@ skipping 152 matching lines @@
 
   // Sets internal parameters to enable upgrade mode (for internal tools).
   void SetUpgradeMode();
 
   // Sets the eviction algorithm to version 2.
   void SetNewEviction();
 
   // Sets an explicit set of BackendFlags.
   void SetFlags(uint32 flags);
 
+  // Clears the index bitmap for tests.
+  void ClearIndexBitmapForTest();
+
   // Clears the counter of references to test handling of corruptions.
   void ClearRefCountForTest();
 
   // Sends a dummy operation through the operation queue, for unit tests.
   int FlushQueueForTest(const CompletionCallback& callback);
 
   // Runs the provided task on the cache thread. The task will be automatically
   // deleted after it runs.
   int RunTaskForTest(const base::Closure& task,
                      const CompletionCallback& callback);
@@ skipping 131 matching lines @@
   uint32 user_flags_;  // Flags set by the user.
   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_;
   bool new_eviction_;  // What eviction algorithm should be used.
   bool first_timer_;  // True if the timer has not been called.
   bool user_load_;  // True if we see a high load coming from the caller.
 
+  Bitmap index_bitmap_;
+
   net::NetLog* net_log_;
 
   Stats stats_;  // Usage statistics.
   scoped_ptr<base::RepeatingTimer<BackendImpl> > timer_;  // Usage timer.
   base::WaitableEvent done_;  // Signals the end of background work.
   scoped_refptr<TraceObject> trace_object_;  // Initializes internal tracing.
   base::WeakPtrFactory<BackendImpl> ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(BackendImpl);
 };
 
 // Returns the preferred max cache size given the available disk space.
 NET_EXPORT_PRIVATE int PreferedCacheSize(int64 available);
 
 }  // namespace disk_cache
 
 #endif  // NET_DISK_CACHE_BACKEND_IMPL_H_