Disk cache: Additional code cleanup after CL 20067.

net/disk_cache/backend_impl.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/backend_impl.h"
 
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/histogram.h"
 #include "base/message_loop.h"
@@ skipping 1085 matching lines @@
   if (!*dirty)
     open_entries_[address.value()] = cache_entry;
 
   cache_entry.swap(entry);
   return 0;
 }
 
 EntryImpl* BackendImpl::MatchEntry(const std::string& key, uint32 hash,
                                    bool find_parent) {
   Addr address(data_->table[hash & mask_]);
-  EntryImpl* cache_entry = NULL;
-  EntryImpl* parent_entry = NULL;
+  scoped_refptr<EntryImpl> cache_entry, parent_entry;
+  EntryImpl* tmp = NULL;
   bool found = false;
 
   for (;;) {
     if (disabled_)
       break;
 
     if (!address.is_initialized()) {
       if (find_parent)
         found = true;
       break;
     }
 
     bool dirty;
-    int error = NewEntry(address, &cache_entry, &dirty);
+    int error = NewEntry(address, &tmp, &dirty);
+    cache_entry.swap(&tmp);
 
     if (error || dirty) {
       // This entry is dirty on disk (it was not properly closed): we cannot
       // trust it.
       Addr child(0);
       if (!error)
         child.set_value(cache_entry->GetNextAddress());
 
       if (parent_entry) {
         parent_entry->SetNextAddress(child);
-        parent_entry->Release();
         parent_entry = NULL;

[Nicolas Sylvain, 2009/07/08 20:25:09]

maybe here and below you could use .reset()?

[rvargas (doing something else), 2009/07/08 20:49:44]

there is no reset() for scoped_refptr

       } else {
         data_->table[hash & mask_] = child.value();
       }
 
       if (!error) {
         // It is important to call DestroyInvalidEntry after removing this
         // entry from the table.
         DestroyInvalidEntry(address, cache_entry);
-        cache_entry->Release();
         cache_entry = NULL;
       } else {
         Trace("NewEntry failed on MatchEntry 0x%x", address.value());
       }
 
       // Restart the search.
       address.set_value(data_->table[hash & mask_]);
       continue;
     }
 
     if (cache_entry->IsSameEntry(key, hash)) {
-      if (!cache_entry->Update()) {
-        cache_entry->Release();
+      if (!cache_entry->Update())
         cache_entry = NULL;
-      }
       found = true;
       break;
     }
-    if (!cache_entry->Update()) {
-      cache_entry->Release();
+    if (!cache_entry->Update())
       cache_entry = NULL;
-    }
-    if (parent_entry)
-      parent_entry->Release();
     parent_entry = cache_entry;
     cache_entry = NULL;
     if (!parent_entry)
       break;
 
     address.set_value(parent_entry->GetNextAddress());
   }
 
-  if (parent_entry && (!find_parent || !found)) {
-    parent_entry->Release();
+  if (parent_entry && (!find_parent || !found))
     parent_entry = NULL;
-  }
 
-  if (cache_entry && (find_parent || !found)) {
-    cache_entry->Release();
+  if (cache_entry && (find_parent || !found))
     cache_entry = NULL;
-  }
 
-  return find_parent ? parent_entry : cache_entry;
+  find_parent ? parent_entry.swap(&tmp) : cache_entry.swap(&tmp);
+  return tmp;
 }
 
 // This is the actual implementation for OpenNextEntry and OpenPrevEntry.
 bool BackendImpl::OpenFollowingEntry(bool forward, void** iter,
                                      Entry** next_entry) {
   if (disabled_)
     return false;
 
   DCHECK(iter);
   DCHECK(next_entry);
@@ skipping 377 matching lines @@
 
   return num_dirty;
 }
 
 bool BackendImpl::CheckEntry(EntryImpl* cache_entry) {
   RankingsNode* rankings = cache_entry->rankings()->Data();
   return !rankings->pointer;
 }
 
 }  // namespace disk_cache