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

net/disk_cache/blockfile/in_flight_backend_io.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/in_flight_backend_io.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
@@ skipping 104 matching lines @@
   operation_ = OP_DOOM_SINCE;
   initial_time_ = initial_time;
 }
 
 void BackendIO::OpenNextEntry(void** iter, Entry** next_entry) {
   operation_ = OP_OPEN_NEXT;
   iter_ptr_ = iter;
   entry_ptr_ = next_entry;
 }
 
-void BackendIO::OpenPrevEntry(void** iter, Entry** prev_entry) {
-  operation_ = OP_OPEN_PREV;
-  iter_ptr_ = iter;
-  entry_ptr_ = prev_entry;
-}
-
 void BackendIO::EndEnumeration(void* iterator) {
   operation_ = OP_END_ENUMERATION;
   iter_ = iterator;
 }
 
 void BackendIO::OnExternalCacheHit(const std::string& key) {
   operation_ = OP_ON_EXTERNAL_CACHE_HIT;
   key_ = key;
 }
 
@@ skipping 70 matching lines @@
 }
 
 void BackendIO::ReadyForSparseIO(EntryImpl* entry) {
   operation_ = OP_IS_READY;
   entry_ = entry;
 }
 
 BackendIO::~BackendIO() {}
 
 bool BackendIO::ReturnsEntry() {
-  return (operation_ == OP_OPEN || operation_ == OP_CREATE ||
-          operation_ == OP_OPEN_NEXT || operation_ == OP_OPEN_PREV);
+  return operation_ == OP_OPEN || operation_ == OP_CREATE ||
+      operation_ == OP_OPEN_NEXT;
 }
 
 base::TimeDelta BackendIO::ElapsedTime() const {
   return base::TimeTicks::Now() - start_time_;
 }
 
 // Runs on the background thread.
 void BackendIO::ExecuteBackendOperation() {
   switch (operation_) {
     case OP_INIT:
@@ skipping 13 matching lines @@
       break;
     case OP_DOOM_BETWEEN:
       result_ = backend_->SyncDoomEntriesBetween(initial_time_, end_time_);
       break;
     case OP_DOOM_SINCE:
       result_ = backend_->SyncDoomEntriesSince(initial_time_);
       break;
     case OP_OPEN_NEXT:
       result_ = backend_->SyncOpenNextEntry(iter_ptr_, entry_ptr_);
       break;
-    case OP_OPEN_PREV:
-      result_ = backend_->SyncOpenPrevEntry(iter_ptr_, entry_ptr_);
-      break;
     case OP_END_ENUMERATION:
       backend_->SyncEndEnumeration(iter_);
       result_ = net::OK;
       break;
     case OP_ON_EXTERNAL_CACHE_HIT:
       backend_->SyncOnExternalCacheHit(key_);
       result_ = net::OK;
       break;
     case OP_CLOSE_ENTRY:
       entry_->Release();
@@ skipping 122 matching lines @@
   PostOperation(operation.get());
 }
 
 void InFlightBackendIO::OpenNextEntry(void** iter, Entry** next_entry,
                                       const net::CompletionCallback& callback) {
   scoped_refptr<BackendIO> operation(new BackendIO(this, backend_, callback));
   operation->OpenNextEntry(iter, next_entry);
   PostOperation(operation.get());
 }
 
-void InFlightBackendIO::OpenPrevEntry(void** iter, Entry** prev_entry,
-                                      const net::CompletionCallback& callback) {
-  scoped_refptr<BackendIO> operation(new BackendIO(this, backend_, callback));
-  operation->OpenPrevEntry(iter, prev_entry);
-  PostOperation(operation.get());
-}
-
 void InFlightBackendIO::EndEnumeration(void* iterator) {
   scoped_refptr<BackendIO> operation(
       new BackendIO(this, backend_, net::CompletionCallback()));
   operation->EndEnumeration(iterator);
   PostOperation(operation.get());
 }
 
 void InFlightBackendIO::OnExternalCacheHit(const std::string& key) {
   scoped_refptr<BackendIO> operation(
       new BackendIO(this, backend_, net::CompletionCallback()));
@@ skipping 100 matching lines @@
   background_thread_->PostTask(
       FROM_HERE, base::Bind(&BackendIO::ExecuteOperation, operation));
   OnOperationPosted(operation);
 }
 
 base::WeakPtr<InFlightBackendIO> InFlightBackendIO::GetWeakPtr() {
   return ptr_factory_.GetWeakPtr();
 }
 
 }  // namespace