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

net/disk_cache/rankings.cc

 // 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.
 
 #include "net/disk_cache/rankings.h"
 
 #include "base/histogram.h"
 #include "net/disk_cache/backend_impl.h"
 #include "net/disk_cache/entry_impl.h"
 #include "net/disk_cache/errors.h"
@@ skipping 186 matching lines @@
 void Rankings::Reset() {
   init_ = false;
   for (int i = 0; i < LAST_ELEMENT; i++) {
     heads_[i].set_value(0);
     tails_[i].set_value(0);
   }
   control_data_ = NULL;
 }
 
 bool Rankings::GetRanking(CacheRankingsBlock* rankings) {
-  Time start = Time::Now();
   if (!rankings->address().is_initialized())
     return false;
 
+  Time start = Time::Now();
   if (!rankings->Load())
     return false;
 
   if (!SanityCheck(rankings, true)) {
     backend_->CriticalError(ERR_INVALID_LINKS);
     return false;
   }
 
-  if (!rankings->Data()->pointer) {
-    backend_->OnEvent(Stats::GET_RANKINGS);
-    return true;
-  }
-
   backend_->OnEvent(Stats::OPEN_RANKINGS);
 
-  if (backend_->GetCurrentEntryId() != rankings->Data()->dirty ||
-      !backend_->IsOpen(rankings)) {
+  // "dummy" is the old "pointer" value, so it has to be 0.
+  if (!rankings->Data()->dirty && !rankings->Data()->dummy)
+    return true;
+
+  EntryImpl* entry = backend_->GetOpenEntry(rankings);
+  if (backend_->GetCurrentEntryId() != rankings->Data()->dirty || !entry) {
     // We cannot trust this entry, but we cannot initiate a cleanup from this
     // point (we may be in the middle of a cleanup already). Just get rid of
     // the invalid pointer and continue; the entry will be deleted when detected
     // from a regular open/create path.
-    rankings->Data()->pointer = NULL;
+    rankings->Data()->dummy = 0;
     rankings->Data()->dirty = backend_->GetCurrentEntryId() - 1;
     if (!rankings->Data()->dirty)
       rankings->Data()->dirty--;
     return true;
   }
 
-  EntryImpl* cache_entry =
-      reinterpret_cast<EntryImpl*>(rankings->Data()->pointer);
-  rankings->SetData(cache_entry->rankings()->Data());
+  // Note that we should not leave this module without deleting rankings first.
+  rankings->SetData(entry->rankings()->Data());
+
   CACHE_UMA(AGE_MS, "GetRankings", 0, start);
   return true;
 }
 
+void Rankings::ConvertToLongLived(CacheRankingsBlock* rankings) {
+  if (rankings->own_data())
+    return;
+
+  // We cannot return a shared node because we are not keeping a reference
+  // to the entry that owns the buffer. Make this node a copy of the one that
+  // we have, and let the iterator logic update it when the entry changes.
+  CacheRankingsBlock temp(NULL, Addr(0));
+  *temp.Data() = *rankings->Data();
+  rankings->StopSharingData();
+  *rankings->Data() = *temp.Data();
+}
+
 void Rankings::Insert(CacheRankingsBlock* node, bool modified, List list) {
   Trace("Insert 0x%x", node->address().value());
   DCHECK(node->HasData());
   Addr& my_head = heads_[list];
   Addr& my_tail = tails_[list];
   Transaction lock(control_data_, node->address(), INSERT, list);
   CacheRankingsBlock head(backend_->File(my_head), my_head);
   if (my_head.is_initialized()) {
     if (!GetRanking(&head))
       return;
@@ skipping 151 matching lines @@
     LOG(ERROR) << "Invalid rankings info.";
     return;
   }
 
   Trace("CompleteTransaction 0x%x", node_addr.value());
 
   CacheRankingsBlock node(backend_->File(node_addr), node_addr);
   if (!node.Load())
     return;
 
-  node.Data()->pointer = NULL;
+  node.Data()->dummy = 0;
   node.Store();
 
   Addr& my_head = heads_[control_data_->operation_list];
   Addr& my_tail = tails_[control_data_->operation_list];
 
   // We want to leave the node inside the list. The entry must me marked as
   // dirty, and will be removed later. Otherwise, we'll get assertions when
   // attempting to remove the dirty entry.
   if (INSERT == control_data_->operation) {
     Trace("FinishInsert h:0x%x t:0x%x", my_head.value(), my_tail.value());
@@ skipping 83 matching lines @@
 }
 
 CacheRankingsBlock* Rankings::GetNext(CacheRankingsBlock* node, List list) {
   ScopedRankingsBlock next(this);
   if (!node) {
     Addr& my_head = heads_[list];
     if (!my_head.is_initialized())
       return NULL;
     next.reset(new CacheRankingsBlock(backend_->File(my_head), my_head));
   } else {
+    if (!node->HasData())
+      node->Load();
     Addr& my_tail = tails_[list];
     if (!my_tail.is_initialized())
       return NULL;
     if (my_tail.value() == node->address().value())
       return NULL;
     Addr address(node->Data()->next);
     if (address.value() == node->address().value())
       return NULL;  // Another tail? fail it.
     next.reset(new CacheRankingsBlock(backend_->File(address), address));
   }
 
   TrackRankingsBlock(next.get(), true);
 
   if (!GetRanking(next.get()))
     return NULL;
 
+  ConvertToLongLived(next.get());
   if (node && !CheckSingleLink(node, next.get()))
     return NULL;
 
   return next.release();
 }
 
 CacheRankingsBlock* Rankings::GetPrev(CacheRankingsBlock* node, List list) {
   ScopedRankingsBlock prev(this);
   if (!node) {
     Addr& my_tail = tails_[list];
     if (!my_tail.is_initialized())
       return NULL;
     prev.reset(new CacheRankingsBlock(backend_->File(my_tail), my_tail));
   } else {
+    if (!node->HasData())
+      node->Load();
     Addr& my_head = heads_[list];
     if (!my_head.is_initialized())
       return NULL;
     if (my_head.value() == node->address().value())
       return NULL;
     Addr address(node->Data()->prev);
     if (address.value() == node->address().value())
       return NULL;  // Another head? fail it.
     prev.reset(new CacheRankingsBlock(backend_->File(address), address));
   }
 
   TrackRankingsBlock(prev.get(), true);
 
   if (!GetRanking(prev.get()))
     return NULL;
 
+  ConvertToLongLived(prev.get());
   if (node && !CheckSingleLink(prev.get(), node))
     return NULL;
 
   return prev.release();
 }
 
 void Rankings::FreeRankingsBlock(CacheRankingsBlock* node) {
   TrackRankingsBlock(node, false);
 }
 
@@ skipping 58 matching lines @@
 
 void Rankings::WriteHead(List list) {
   control_data_->heads[list] = heads_[list].value();
 }
 
 void Rankings::WriteTail(List list) {
   control_data_->tails[list] = tails_[list].value();
 }
 
 bool Rankings::CheckEntry(CacheRankingsBlock* rankings) {
-  if (!rankings->Data()->pointer)
+  if (!rankings->Data()->dummy)
     return true;
 
   // If this entry is not dirty, it is a serious problem.
   return backend_->GetCurrentEntryId() != rankings->Data()->dirty;
 }
 
 bool Rankings::CheckLinks(CacheRankingsBlock* node, CacheRankingsBlock* prev,
                           CacheRankingsBlock* next, List list) {
   if ((prev->Data()->next != node->address().value() &&
        heads_[list].value() != node->address().value()) ||
@@ skipping 86 matching lines @@
 
 // We expect to have just a few iterators at any given time, maybe two or three,
 // But we could have more than one pointing at the same mode. We walk the list
 // of cache iterators and update all that are pointing to the given node.
 void Rankings::UpdateIterators(CacheRankingsBlock* node) {
   CacheAddr address = node->address().value();
   for (IteratorList::iterator it = iterators_.begin(); it != iterators_.end();
        ++it) {
     if (it->first == address && it->second->HasData()) {
       CacheRankingsBlock* other = it->second;
-      other->Data()->next = node->Data()->next;
-      other->Data()->prev = node->Data()->prev;
+      *other->Data() = *node->Data();
     }
   }
 }
 
 void Rankings::InvalidateIterators(CacheRankingsBlock* node) {
   CacheAddr address = node->address().value();
   for (IteratorList::iterator it = iterators_.begin(); it != iterators_.end();
        ++it) {
     if (it->first == address) {
       LOG(WARNING) << "Invalidating iterator at 0x" << std::hex << address;
@@ skipping 14 matching lines @@
 void Rankings::DecrementCounter(List list) {
   if (!count_lists_)
     return;
 
   DCHECK(control_data_->sizes[list] > 0);
   if (control_data_->sizes[list] > 0)
     control_data_->sizes[list]--;
 }
 
 }  // namespace disk_cache