Disk Cache: Remove deprecated methods from the disk cache interface....

net/http/http_cache_unittest.cc

 // Copyright (c) 2006-2010 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/http/http_cache.h"
 
 #include "base/hash_tables.h"
 #include "base/message_loop.h"
 #include "base/scoped_vector.h"
 #include "base/string_util.h"
@@ skipping 197 matching lines @@
       data_[1].resize(real_offset + buf_len);
 
     memcpy(&data_[1][real_offset], buf->data(), buf_len);
     if (GetEffectiveTestMode(test_mode_) & TEST_MODE_SYNC_CACHE_WRITE)
       return buf_len;
 
     CallbackLater(callback, buf_len);
     return net::ERR_IO_PENDING;
   }
 
-  virtual int GetAvailableRange(int64 offset, int len, int64* start) {
-    NOTREACHED();
-    return net::ERR_NOT_IMPLEMENTED;
-  }
-
   virtual int GetAvailableRange(int64 offset, int len, int64* start,
                                 net::CompletionCallback* callback) {
     DCHECK(callback);
     if (!sparse_ || busy_)
       return net::ERR_CACHE_OPERATION_NOT_SUPPORTED;
     if (offset < 0)
       return net::ERR_FAILED;
 
     if (fail_requests_)
       return net::ERR_CACHE_READ_FAILURE;
@@ skipping 143 matching lines @@
   ~MockDiskCache() {
     EntryMap::iterator it = entries_.begin();
     for (; it != entries_.end(); ++it)
       it->second->Release();
   }
 
   virtual int32 GetEntryCount() const {
     return static_cast<int32>(entries_.size());
   }
 
-  virtual bool OpenEntry(const std::string& key, disk_cache::Entry** entry) {
-    NOTREACHED();
-    return false;
-  }
-
   virtual int OpenEntry(const std::string& key, disk_cache::Entry** entry,
                         net::CompletionCallback* callback) {
     DCHECK(callback);
     if (fail_requests_)
       return net::ERR_CACHE_OPEN_FAILURE;
 
     EntryMap::iterator it = entries_.find(key);
     if (it == entries_.end())
       return net::ERR_CACHE_OPEN_FAILURE;
 
@@ skipping 11 matching lines @@
     if (soft_failures_)
       it->second->set_fail_requests();
 
     if (GetTestModeForEntry(key) & TEST_MODE_SYNC_CACHE_START)
       return net::OK;
 
     CallbackLater(callback, net::OK);
     return net::ERR_IO_PENDING;
   }
 
-  virtual bool CreateEntry(const std::string& key, disk_cache::Entry** entry) {
-    NOTREACHED();
-    return false;
-  }
-
   virtual int CreateEntry(const std::string& key, disk_cache::Entry** entry,
                           net::CompletionCallback* callback) {
     DCHECK(callback);
     if (fail_requests_)
       return net::ERR_CACHE_CREATE_FAILURE;
 
     EntryMap::iterator it = entries_.find(key);
     if (it != entries_.end()) {
       DCHECK(it->second->is_doomed());
       it->second->Release();
@@ skipping 13 matching lines @@
     if (soft_failures_)
       new_entry->set_fail_requests();
 
     if (GetTestModeForEntry(key) & TEST_MODE_SYNC_CACHE_START)
       return net::OK;
 
     CallbackLater(callback, net::OK);
     return net::ERR_IO_PENDING;
   }
 
-  virtual bool DoomEntry(const std::string& key) {
-    NOTREACHED();
-    return false;
-  }
-
   virtual int DoomEntry(const std::string& key,
                         net::CompletionCallback* callback) {
     DCHECK(callback);
     EntryMap::iterator it = entries_.find(key);
     if (it != entries_.end()) {
       it->second->Release();
       entries_.erase(it);
     }
 
     if (GetTestModeForEntry(key) & TEST_MODE_SYNC_CACHE_START)
       return net::OK;
 
     CallbackLater(callback, net::OK);
     return net::ERR_IO_PENDING;
   }
 
-  virtual bool DoomAllEntries() {
-    NOTREACHED();
-    return false;
-  }
-
   virtual int DoomAllEntries(net::CompletionCallback* callback) {
     return net::ERR_NOT_IMPLEMENTED;
   }
 
-  virtual bool DoomEntriesBetween(const Time initial_time,
-                                  const Time end_time) {
-    NOTREACHED();
-    return false;
-  }
-
   virtual int DoomEntriesBetween(const base::Time initial_time,
                                  const base::Time end_time,
                                  net::CompletionCallback* callback) {
     return net::ERR_NOT_IMPLEMENTED;
   }
 
-  virtual bool DoomEntriesSince(const Time initial_time) {
-    NOTREACHED();
-    return false;
-  }
-
   virtual int DoomEntriesSince(const base::Time initial_time,
                                net::CompletionCallback* callback) {
     return net::ERR_NOT_IMPLEMENTED;
   }
 
-  virtual bool OpenNextEntry(void** iter, disk_cache::Entry** next_entry) {
-    NOTREACHED();
-    return false;
-  }
-
   virtual int OpenNextEntry(void** iter, disk_cache::Entry** next_entry,
                             net::CompletionCallback* callback) {
     return net::ERR_NOT_IMPLEMENTED;
   }
 
   virtual void EndEnumeration(void** iter) {}
 
   virtual void GetStats(
       std::vector<std::pair<std::string, std::string> >* stats) {
   }
@@ skipping 4109 matching lines @@
   // Now return 200 when validating the entry so the metadata will be lost.
   MockTransaction trans2(kTypicalGET_Transaction);
   trans2.load_flags = net::LOAD_VALIDATE_CACHE;
   RunTransactionTestWithResponseInfo(cache.http_cache(), trans2, &response);
   EXPECT_TRUE(response.metadata.get() == NULL);
 
   EXPECT_EQ(3, cache.network_layer()->transaction_count());
   EXPECT_EQ(4, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 }