Disk cache: Add a hash to the entry's internal data.

net/disk_cache/storage_block-inl.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.
 
 #ifndef NET_DISK_CACHE_STORAGE_BLOCK_INL_H_
 #define NET_DISK_CACHE_STORAGE_BLOCK_INL_H_
 #pragma once
 
 #include "net/disk_cache/storage_block.h"
 
 #include "base/logging.h"
+#include "net/disk_cache/hash.h"
 #include "net/disk_cache/trace.h"
 
 namespace disk_cache {
 
 template<typename T> StorageBlock<T>::StorageBlock(MappedFile* file,
                                                    Addr address)
     : data_(NULL), file_(file), address_(address), modified_(false),
       own_data_(false), extended_(false) {
   if (address.num_blocks() > 1)
     extended_ = true;
@@ skipping 69 matching lines @@
 template<typename T> T* StorageBlock<T>::Data() {
   if (!data_)
     AllocateData();
   return data_;
 }
 
 template<typename T> bool StorageBlock<T>::HasData() const {
   return (NULL != data_);
 }
 
+template<typename T> bool StorageBlock<T>::VerifyHash() const {
+  uint32 hash = CalculateHash();
+  return (!data_->self_hash || data_->self_hash == hash);
+}
+
 template<typename T> bool StorageBlock<T>::own_data() const {
   return own_data_;
 }
 
 template<typename T> const Addr StorageBlock<T>::address() const {
   return address_;
 }
 
 template<typename T> bool StorageBlock<T>::Load() {
   if (file_) {
     if (!data_)
       AllocateData();
 
     if (file_->Load(this)) {
       modified_ = false;
       return true;
     }
   }
   LOG(WARNING) << "Failed data load.";
   Trace("Failed data load.");
   return false;
 }
 
 template<typename T> bool StorageBlock<T>::Store() {
   if (file_ && data_) {
+    data_->self_hash = CalculateHash();
     if (file_->Store(this)) {
       modified_ = false;
       return true;
     }
   }
   LOG(ERROR) << "Failed data store.";
   Trace("Failed data store.");
   return false;
 }
 
@@ skipping 13 matching lines @@
     if (!extended_) {
       delete data_;
     } else {
       data_->~T();
       delete[] reinterpret_cast<char*>(data_);
     }
     own_data_ = false;
   }
 }
 
+template<typename T> uint32 StorageBlock<T>::CalculateHash() const {
+  return Hash(reinterpret_cast<char*>(data_), offsetof(T, self_hash));
+}
+
 }  // namespace disk_cache
 
 #endif  // NET_DISK_CACHE_STORAGE_BLOCK_INL_H_