Disk cache: Remove remaining uses of RankingsNode.pointer....

net/disk_cache/entry_impl.cc

 // Copyright (c) 2006-2009 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/histogram.h"
 #include "base/message_loop.h"
 #include "base/string_util.h"
 #include "net/base/io_buffer.h"
@@ skipping 92 matching lines @@
     for (int index = 0; index < kNumStreams; index++) {
       if (user_buffers_[index].get()) {
         if (!(ret = Flush(index, entry_.Data()->data_size[index], false)))
           LOG(ERROR) << "Failed to save user data";
       } else if (unreported_size_[index]) {
         backend_->ModifyStorageSize(
             entry_.Data()->data_size[index] - unreported_size_[index],
             entry_.Data()->data_size[index]);
       }
     }
-    if (node_.HasData() && this == node_.Data()->pointer) {
-      // We have to do this after Flush because we may trigger a cache trim from
-      // there, and technically this entry should be "in use".
-      node_.Data()->pointer = NULL;
-      node_.set_modified();
-    }
 
     if (!ret) {
       // There was a failure writing the actual data. Mark the entry as dirty.
       int current_id = backend_->GetCurrentEntryId();
       node_.Data()->dirty = current_id == 1 ? -1 : current_id - 1;
       node_.Store();
     } else if (node_.HasData() && node_.Data()->dirty) {
       node_.Data()->dirty = 0;
       node_.Store();
     }
@@ skipping 262 matching lines @@
   Trace("Create entry In");
   EntryStore* entry_store = entry_.Data();
   RankingsNode* node = node_.Data();
   memset(entry_store, 0, sizeof(EntryStore) * entry_.address().num_blocks());
   memset(node, 0, sizeof(RankingsNode));
   if (!node_.LazyInit(backend_->File(node_address), node_address))
     return false;
 
   entry_store->rankings_node = node_address.value();
   node->contents = entry_.address().value();
-  node->pointer = this;
 
   entry_store->hash = hash;
   entry_store->creation_time = Time::Now().ToInternalValue();
   entry_store->key_len = static_cast<int32>(key.size());
   if (entry_store->key_len > kMaxInternalKeyLength) {
     Addr address(0);
     if (!CreateBlock(entry_store->key_len + 1, &address))
       return false;
 
     entry_store->long_key = address.value();
@@ skipping 96 matching lines @@
   Addr address(entry_.Data()->rankings_node);
   if (!node_.LazyInit(backend_->File(address), address))
     return false;
   return node_.Load();
 }
 
 bool EntryImpl::Update() {
   DCHECK(node_.HasData());
 
   RankingsNode* rankings = node_.Data();
-  if (rankings->pointer) {
-    // Nothing to do here, the entry was in memory.
-    DCHECK(rankings->pointer == this);
-  } else {
+  if (!rankings->dirty) {
     rankings->dirty = backend_->GetCurrentEntryId();
-    rankings->pointer = this;
     if (!node_.Store())
       return false;
   }
   return true;
 }
 
 bool EntryImpl::IsDirty(int32 current_id) {
   DCHECK(node_.HasData());
   // We are checking if the entry is valid or not. If there is a pointer here,
   // we should not be checking the entry.
-  if (node_.Data()->pointer)
+  if (node_.Data()->dummy)
     return true;
 
   return node_.Data()->dirty && current_id != node_.Data()->dirty;
 }
 
 void EntryImpl::ClearDirtyFlag() {
   node_.Data()->dirty = 0;
 }
 
 void EntryImpl::SetPointerForInvalidEntry(int32 new_id) {
   node_.Data()->dirty = new_id;
-  node_.Data()->pointer = this;
+  node_.Data()->dummy = 0;
   node_.Store();
 }
 
 bool EntryImpl::SanityCheck() {
   if (!entry_.Data()->rankings_node || !entry_.Data()->key_len)
     return false;
 
   Addr rankings_addr(entry_.Data()->rankings_node);
   if (!rankings_addr.is_initialized() || rankings_addr.is_separate_file() ||
       rankings_addr.file_type() != RANKINGS)
@@ skipping 328 matching lines @@
       break;
     case kSparseWrite:
       CACHE_UMA(AGE_MS, "SparseWriteTime", 0, start);
       break;
     default:
       NOTREACHED();
   }
 }
 
 void EntryImpl::Log(const char* msg) {
-  void* pointer = NULL;
   int dirty = 0;
   if (node_.HasData()) {
-    pointer = node_.Data()->pointer;
     dirty = node_.Data()->dirty;
   }
 
   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%p 0x%x", doomed_, pointer, dirty);
+  Trace("  doomed: %d 0x%x", doomed_, dirty);
 }
 
 }  // namespace disk_cache