Remove partial blockfile v3 disk_cache implementation.

net/disk_cache/blockfile/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/blockfile/entry_impl.h"
 
 #include <limits>
 
 #include "base/hash.h"
 #include "base/macros.h"
@@ skipping 574 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.SanityCheckForEntryV2()) {
+  if (next_addr.is_initialized() && !next_addr.SanityCheckForEntry()) {
     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.SanityCheckV2())
+  if (!key_addr.SanityCheck())
     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.SanityCheckV2())
+    if (!data_addr.SanityCheck())
       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.SanityCheckV2()) {
+          !data_addr.SanityCheck()) {
         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 880 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