Update about:cache to display cached metadata for an entry....

net/http/http_cache_unittest.cc

 // Copyright (c) 2006-2010 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.
 
 #include "net/http/http_cache.h"
 
 #include "base/hash_tables.h"
 #include "base/message_loop.h"
 #include "base/scoped_vector.h"
 #include "base/string_util.h"
@@ skipping 44 matching lines @@
 int GetEffectiveTestMode(int test_mode) {
   if (!g_test_mode)
     return test_mode;
 
   return g_test_mode;
 }
 
 //-----------------------------------------------------------------------------
 // mock disk cache (a very basic memory cache implementation)
 
+static const int kNumCacheEntryDataIndices = 3;
+
 class MockDiskEntry : public disk_cache::Entry,
                       public base::RefCounted<MockDiskEntry> {
  public:
   MockDiskEntry()
       : test_mode_(0), doomed_(false), sparse_(false), fail_requests_(false),
         busy_(false), delayed_(false) {
   }
 
   explicit MockDiskEntry(const std::string& key)
       : key_(key), doomed_(false), sparse_(false), fail_requests_(false),
@@ skipping 19 matching lines @@
 
   virtual Time GetLastUsed() const {
     return Time::FromInternalValue(0);
   }
 
   virtual Time GetLastModified() const {
     return Time::FromInternalValue(0);
   }
 
   virtual int32 GetDataSize(int index) const {
-    DCHECK(index >= 0 && index < 3);
+    DCHECK(index >= 0 && index < kNumCacheEntryDataIndices);
     return static_cast<int32>(data_[index].size());
   }
 
   virtual int ReadData(int index, int offset, net::IOBuffer* buf, int buf_len,
                        net::CompletionCallback* callback) {
-    DCHECK(index >= 0 && index < 3);
+    DCHECK(index >= 0 && index < kNumCacheEntryDataIndices);
 
     if (fail_requests_)
       return net::ERR_CACHE_READ_FAILURE;
 
     if (offset < 0 || offset > static_cast<int>(data_[index].size()))
       return net::ERR_FAILED;
     if (static_cast<size_t>(offset) == data_[index].size())
       return 0;
 
     int num = std::min(buf_len, static_cast<int>(data_[index].size()) - offset);
     memcpy(buf->data(), &data_[index][offset], num);
 
     if (!callback ||
         (GetEffectiveTestMode(test_mode_) & TEST_MODE_SYNC_CACHE_READ))
       return num;
 
     CallbackLater(callback, num);
     return net::ERR_IO_PENDING;
   }
 
   virtual int WriteData(int index, int offset, net::IOBuffer* buf, int buf_len,
                         net::CompletionCallback* callback, bool truncate) {
-    DCHECK(index >= 0 && index < 3);
+    DCHECK(index >= 0 && index < kNumCacheEntryDataIndices);
     DCHECK(truncate);
 
     if (fail_requests_)
       return net::ERR_CACHE_READ_FAILURE;
 
     if (offset < 0 || offset > static_cast<int>(data_[index].size()))
       return net::ERR_FAILED;
 
     data_[index].resize(offset + buf_len);
     if (buf_len)
@@ skipping 187 matching lines @@
     } else {
       for (size_t i = 0; i < callback_list.size(); i++) {
         CallbackInfo& c = callback_list[i];
         c.entry->CallbackLater(c.callback, c.result);
       }
       callback_list.clear();
     }
   }
 
   std::string key_;
-  std::vector<char> data_[3];
+  std::vector<char> data_[kNumCacheEntryDataIndices];
   int test_mode_;
   bool doomed_;
   bool sparse_;
   bool fail_requests_;
   bool busy_;
   bool delayed_;
   static bool cancel_;
   static bool ignore_callbacks_;
 };
 
@@ skipping 3992 matching lines @@
   // Now return 200 when validating the entry so the metadata will be lost.
   MockTransaction trans2(kTypicalGET_Transaction);
   trans2.load_flags = net::LOAD_VALIDATE_CACHE;
   RunTransactionTestWithResponseInfo(cache.http_cache(), trans2, &response);
   EXPECT_TRUE(response.metadata.get() == NULL);
 
   EXPECT_EQ(3, cache.network_layer()->transaction_count());
   EXPECT_EQ(4, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 }