Remove disk_cache::BackendImpl::OpenPrevEntry() and all users.

net/disk_cache/blockfile/backend_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/backend_impl.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/files/file.h"
 #include "base/files/file_path.h"
@@ skipping 310 matching lines @@
   }
   block_files_.CloseFiles();
   FlushIndex();
   index_ = NULL;
   ptr_factory_.InvalidateWeakPtrs();
   done_.Signal();
 }
 
 // ------------------------------------------------------------------------
 
-int BackendImpl::OpenPrevEntry(void** iter, Entry** prev_entry,
-                               const CompletionCallback& callback) {
-  DCHECK(!callback.is_null());
-  background_queue_.OpenPrevEntry(iter, prev_entry, callback);
-  return net::ERR_IO_PENDING;
-}
-
 int BackendImpl::SyncOpenEntry(const std::string& key, Entry** entry) {
   DCHECK(entry);
   *entry = OpenEntryImpl(key);
   return (*entry) ? net::OK : net::ERR_FAILED;
 }
 
 int BackendImpl::SyncCreateEntry(const std::string& key, Entry** entry) {
   DCHECK(entry);
   *entry = CreateEntryImpl(key);
   return (*entry) ? net::OK : net::ERR_FAILED;
@@ skipping 89 matching lines @@
     entry->Release();
     SyncEndEnumeration(iter);  // Dooming the entry invalidates the iterator.
   }
 }
 
 int BackendImpl::SyncOpenNextEntry(void** iter, Entry** next_entry) {
   *next_entry = OpenNextEntryImpl(iter);
   return (*next_entry) ? net::OK : net::ERR_FAILED;
 }
 
-int BackendImpl::SyncOpenPrevEntry(void** iter, Entry** prev_entry) {
-  *prev_entry = OpenPrevEntryImpl(iter);
-  return (*prev_entry) ? net::OK : net::ERR_FAILED;
-}
-
 void BackendImpl::SyncEndEnumeration(void* iter) {
   scoped_ptr<Rankings::Iterator> iterator(
       reinterpret_cast<Rankings::Iterator*>(iter));
 }
 
 void BackendImpl::SyncOnExternalCacheHit(const std::string& key) {
   if (disabled_)
     return;
 
   uint32 hash = base::Hash(key);
@@ skipping 148 matching lines @@
   CACHE_UMA(AGE_MS, "CreateTime", 0, start);
   stats_.OnEvent(Stats::CREATE_HIT);
   SIMPLE_STATS_COUNTER("disk_cache.miss");
   Trace("create entry hit ");
   FlushIndex();
   cache_entry->AddRef();
   return cache_entry.get();
 }
 
 EntryImpl* BackendImpl::OpenNextEntryImpl(void** iter) {
-  return OpenFollowingEntry(true, iter);
-}
+  if (disabled_)
+    return NULL;
 
-EntryImpl* BackendImpl::OpenPrevEntryImpl(void** iter) {
-  return OpenFollowingEntry(false, iter);
+  DCHECK(iter);
+
+  const int kListsToSearch = 3;
+  scoped_refptr<EntryImpl> entries[kListsToSearch];
+  scoped_ptr<Rankings::Iterator> iterator(
+      reinterpret_cast<Rankings::Iterator*>(*iter));
+  *iter = NULL;
+
+  if (!iterator.get()) {
+    iterator.reset(new Rankings::Iterator(&rankings_));
+    bool ret = false;
+
+    // Get an entry from each list.
+    for (int i = 0; i < kListsToSearch; i++) {
+      EntryImpl* temp = NULL;
+      ret |= OpenFollowingEntryFromList(static_cast<Rankings::List>(i),
+                                        &iterator->nodes[i], &temp);
+      entries[i].swap(&temp);  // The entry was already addref'd.
+    }
+    if (!ret)
+      return NULL;
+  } else {
+    // Get the next entry from the last list, and the actual entries for the
+    // elements on the other lists.
+    for (int i = 0; i < kListsToSearch; i++) {
+      EntryImpl* temp = NULL;
+      if (iterator->list == i) {
+          OpenFollowingEntryFromList(
+              iterator->list, &iterator->nodes[i], &temp);
+      } else {
+        temp = GetEnumeratedEntry(iterator->nodes[i],
+                                  static_cast<Rankings::List>(i));
+      }
+
+      entries[i].swap(&temp);  // The entry was already addref'd.
+    }
+  }
+
+  int newest = -1;
+  int oldest = -1;
+  Time access_times[kListsToSearch];
+  for (int i = 0; i < kListsToSearch; i++) {
+    if (entries[i].get()) {
+      access_times[i] = entries[i]->GetLastUsed();
+      if (newest < 0) {
+        DCHECK_LT(oldest, 0);
+        newest = oldest = i;
+        continue;
+      }
+      if (access_times[i] > access_times[newest])
+        newest = i;
+      if (access_times[i] < access_times[oldest])
+        oldest = i;
+    }
+  }
+
+  if (newest < 0 || oldest < 0)
+    return NULL;
+
+  EntryImpl* next_entry;
+  next_entry = entries[newest].get();
+  iterator->list = static_cast<Rankings::List>(newest);
+  *iter = iterator.release();
+  next_entry->AddRef();
+  return next_entry;
 }
 
 bool BackendImpl::SetMaxSize(int max_bytes) {
   COMPILE_ASSERT(sizeof(max_bytes) == sizeof(max_size_), unsupported_int_model);
   if (max_bytes < 0)
     return false;
 
   // Zero size means use the default.
   if (!max_bytes)
     return true;
@@ skipping 977 matching lines @@
   }
 
   if (cache_entry.get() && (find_parent || !found))
     cache_entry = NULL;
 
   find_parent ? parent_entry.swap(&tmp) : cache_entry.swap(&tmp);
   FlushIndex();
   return tmp;
 }
 
-// This is the actual implementation for OpenNextEntry and OpenPrevEntry.
-EntryImpl* BackendImpl::OpenFollowingEntry(bool forward, void** iter) {
-  if (disabled_)
-    return NULL;
-
-  DCHECK(iter);
-
-  const int kListsToSearch = 3;
-  scoped_refptr<EntryImpl> entries[kListsToSearch];
-  scoped_ptr<Rankings::Iterator> iterator(
-      reinterpret_cast<Rankings::Iterator*>(*iter));
-  *iter = NULL;
-
-  if (!iterator.get()) {
-    iterator.reset(new Rankings::Iterator(&rankings_));
-    bool ret = false;
-
-    // Get an entry from each list.
-    for (int i = 0; i < kListsToSearch; i++) {
-      EntryImpl* temp = NULL;
-      ret |= OpenFollowingEntryFromList(forward, static_cast<Rankings::List>(i),
-                                        &iterator->nodes[i], &temp);
-      entries[i].swap(&temp);  // The entry was already addref'd.
-    }
-    if (!ret)
-      return NULL;
-  } else {
-    // Get the next entry from the last list, and the actual entries for the
-    // elements on the other lists.
-    for (int i = 0; i < kListsToSearch; i++) {
-      EntryImpl* temp = NULL;
-      if (iterator->list == i) {
-          OpenFollowingEntryFromList(forward, iterator->list,
-                                     &iterator->nodes[i], &temp);
-      } else {
-        temp = GetEnumeratedEntry(iterator->nodes[i],
-                                  static_cast<Rankings::List>(i));
-      }
-
-      entries[i].swap(&temp);  // The entry was already addref'd.
-    }
-  }
-
-  int newest = -1;
-  int oldest = -1;
-  Time access_times[kListsToSearch];
-  for (int i = 0; i < kListsToSearch; i++) {
-    if (entries[i].get()) {
-      access_times[i] = entries[i]->GetLastUsed();
-      if (newest < 0) {
-        DCHECK_LT(oldest, 0);
-        newest = oldest = i;
-        continue;
-      }
-      if (access_times[i] > access_times[newest])
-        newest = i;
-      if (access_times[i] < access_times[oldest])
-        oldest = i;
-    }
-  }
-
-  if (newest < 0 || oldest < 0)
-    return NULL;
-
-  EntryImpl* next_entry;
-  if (forward) {
-    next_entry = entries[newest].get();
-    iterator->list = static_cast<Rankings::List>(newest);
-  } else {
-    next_entry = entries[oldest].get();
-    iterator->list = static_cast<Rankings::List>(oldest);
-  }
-
-  *iter = iterator.release();
-  next_entry->AddRef();
-  return next_entry;
-}
-
-bool BackendImpl::OpenFollowingEntryFromList(bool forward, Rankings::List list,
+bool BackendImpl::OpenFollowingEntryFromList(Rankings::List list,
                                              CacheRankingsBlock** from_entry,
                                              EntryImpl** next_entry) {
   if (disabled_)
     return false;
 
   if (!new_eviction_ && Rankings::NO_USE != list)
     return false;
 
   Rankings::ScopedRankingsBlock rankings(&rankings_, *from_entry);
-  CacheRankingsBlock* next_block = forward ?
-      rankings_.GetNext(rankings.get(), list) :
-      rankings_.GetPrev(rankings.get(), list);
+  CacheRankingsBlock* next_block = rankings_.GetNext(rankings.get(), list);
   Rankings::ScopedRankingsBlock next(&rankings_, next_block);
   *from_entry = NULL;
 
   *next_entry = GetEnumeratedEntry(next.get(), list);
   if (!*next_entry)
     return false;
 
   *from_entry = next.release();
   return true;
 }
@@ skipping 372 matching lines @@
     if (total_memory > kMaxBuffersSize || total_memory <= 0)
       total_memory = kMaxBuffersSize;
 
     done = true;
   }
 
   return static_cast<int>(total_memory);
 }
 
 }  // namespace disk_cache