Disk cache: Reference CL for the implementation of file format version 3.

net/disk_cache/entry_impl.cc

 // 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.
 
 #include "net/disk_cache/entry_impl.h"
 
 #include "base/hash.h"
 #include "base/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/string_util.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/disk_cache/backend_impl.h"
 #include "net/disk_cache/bitmap.h"
 #include "net/disk_cache/cache_util.h"
+#include "net/disk_cache/disk_format.h"
 #include "net/disk_cache/histogram_macros.h"
 #include "net/disk_cache/net_log_parameters.h"
 #include "net/disk_cache/sparse_control.h"
 
 using base::Time;
 using base::TimeDelta;
 using base::TimeTicks;
 
 namespace {
 
@@ skipping 548 matching lines @@
     return false;
 
   if (stored->reuse_count < 0 || stored->refetch_count < 0)
     return false;
 
   Addr rankings_addr(stored->rankings_node);
   if (!rankings_addr.SanityCheckForRankings())
     return false;
 
   Addr next_addr(stored->next);
-  if (next_addr.is_initialized() && !next_addr.SanityCheckForEntry()) {
+  if (next_addr.is_initialized() && !next_addr.SanityCheckForEntryV2()) {
     STRESS_NOTREACHED();
     return false;
   }
   STRESS_DCHECK(next_addr.value() != entry_.address().value());
 
   if (stored->state > ENTRY_DOOMED || stored->state < ENTRY_NORMAL)
     return false;
 
   Addr key_addr(stored->long_key);
   if ((stored->key_len <= kMaxInternalKeyLength && key_addr.is_initialized()) ||
       (stored->key_len > kMaxInternalKeyLength && !key_addr.is_initialized()))
     return false;
 
-  if (!key_addr.SanityCheck())
+  if (!key_addr.SanityCheckV2())
     return false;
 
   if (key_addr.is_initialized() &&
       ((stored->key_len < kMaxBlockSize && key_addr.is_separate_file()) ||
        (stored->key_len >= kMaxBlockSize && key_addr.is_block_file())))
     return false;
 
   int num_blocks = NumBlocksForEntry(stored->key_len);
   if (entry_.address().num_blocks() != num_blocks)
     return false;
@@ skipping 12 matching lines @@
   if (stored->hash != base::Hash(GetKey()))
     return false;
 
   for (int i = 0; i < kNumStreams; i++) {
     Addr data_addr(stored->data_addr[i]);
     int data_size = stored->data_size[i];
     if (data_size < 0)
       return false;
     if (!data_size && data_addr.is_initialized())
       return false;
-    if (!data_addr.SanityCheck())
+    if (!data_addr.SanityCheckV2())
       return false;
     if (!data_size)
       continue;
     if (data_size <= kMaxBlockSize && data_addr.is_separate_file())
       return false;
     if (data_size > kMaxBlockSize && data_addr.is_block_file())
       return false;
   }
   return true;
 }
 
 void EntryImpl::FixForDelete() {
   EntryStore* stored = entry_.Data();
   Addr key_addr(stored->long_key);
 
   if (!key_addr.is_initialized())
     stored->key[stored->key_len] = '\0';
 
   for (int i = 0; i < kNumStreams; i++) {
     Addr data_addr(stored->data_addr[i]);
     int data_size = stored->data_size[i];
     if (data_addr.is_initialized()) {
       if ((data_size <= kMaxBlockSize && data_addr.is_separate_file()) ||
           (data_size > kMaxBlockSize && data_addr.is_block_file()) ||
-          !data_addr.SanityCheck()) {
+          !data_addr.SanityCheckV2()) {
         STRESS_NOTREACHED();
         // The address is weird so don't attempt to delete it.
         stored->data_addr[i] = 0;
         // In general, trust the stored size as it should be in sync with the
         // total size tracked by the backend.
       }
     }
     if (data_size < 0)
       stored->data_size[i] = 0;
   }
@@ skipping 507 matching lines @@
   if (!backend_)
     return false;
 
   FileType file_type = Addr::RequiredFileType(size);
   if (EXTERNAL == file_type) {
     if (size > backend_->MaxFileSize())
       return false;
     if (!backend_->CreateExternalFile(address))
       return false;
   } else {
-    int num_blocks = (size + Addr::BlockSizeForFileType(file_type) - 1) /
-                     Addr::BlockSizeForFileType(file_type);
+    int num_blocks = Addr::RequiredBlocks(size, file_type);
 
     if (!backend_->CreateBlock(file_type, num_blocks, address))
       return false;
   }
   return true;
 }
 
 // Note that this method may end up modifying a block file so upon return the
 // involved block will be free, and could be reused for something else. If there
 // is a crash after that point (and maybe before returning to the caller), the
@@ skipping 86 matching lines @@
 
     if (!user_buffers_[index].get() && offset < kMaxBlockSize) {
       // We are about to create a buffer for the first 16KB, make sure that we
       // preserve existing data.
       if (!CopyToLocalBuffer(index))
         return false;
     }
   }
 
   if (!user_buffers_[index].get())
-    user_buffers_[index].reset(new UserBuffer(backend_));
+    user_buffers_[index].reset(new UserBuffer(backend_.get()));
 
   return PrepareBuffer(index, offset, buf_len);
 }
 
 // We get to this function with some data already stored. If there is a
 // truncation that results on data stored internally, we'll explicitly
 // handle the case here.
 bool EntryImpl::HandleTruncation(int index, int offset, int buf_len) {
   Addr address(entry_.Data()->data_addr[index]);
 
@@ skipping 50 matching lines @@
 
   return ImportSeparateFile(index, offset + buf_len);
 }
 
 bool EntryImpl::CopyToLocalBuffer(int index) {
   Addr address(entry_.Data()->data_addr[index]);
   DCHECK(!user_buffers_[index].get());
   DCHECK(address.is_initialized());
 
   int len = std::min(entry_.Data()->data_size[index], kMaxBlockSize);
-  user_buffers_[index].reset(new UserBuffer(backend_));
+  user_buffers_[index].reset(new UserBuffer(backend_.get()));
   user_buffers_[index]->Write(len, NULL, 0);
 
   File* file = GetBackingFile(address, index);
   int offset = 0;
 
   if (address.is_block_file())
     offset = address.start_block() * address.BlockSize() + kBlockHeaderSize;
 
   if (!file ||
       !file->Read(user_buffers_[index]->Data(), len, offset, NULL, NULL)) {
@@ skipping 167 matching lines @@
   Trace("%s 0x%p 0x%x 0x%x", msg, reinterpret_cast<void*>(this),
         entry_.address().value(), node_.address().value());
 
   Trace("  data: 0x%x 0x%x 0x%x", entry_.Data()->data_addr[0],
         entry_.Data()->data_addr[1], entry_.Data()->long_key);
 
   Trace("  doomed: %d 0x%x", doomed_, dirty);
 }
 
 }  // namespace disk_cache