Disk Cache: New interface that enables asynchronous completion...

net/http/http_cache_unittest.cc

 // Copyright (c) 2006-2009 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 210 matching lines @@
         }
       } else {
         if (!data_[1][real_offset])
           break;
         count++;
       }
     }
     return count;
   }
 
+  virtual int GetAvailableRange(int64 offset, int len, int64* start,
+                                net::CompletionCallback* callback) {
+    return net::ERR_NOT_IMPLEMENTED;
+  }
+
   virtual void CancelSparseIO() { cancel_ = true; }
 
   virtual int ReadyForSparseIO(net::CompletionCallback* completion_callback) {
     if (!cancel_)
       return net::OK;
 
     cancel_ = false;
     DCHECK(completion_callback);
     if (test_mode_ & TEST_MODE_SYNC_CACHE_READ)
       return net::OK;
@@ skipping 83 matching lines @@
 
     it->second->AddRef();
     *entry = it->second;
 
     if (soft_failures_)
       it->second->set_fail_requests();
 
     return true;
   }
 
+  virtual int OpenEntry(const std::string& key, disk_cache::Entry** entry,
+                        net::CompletionCallback* callback) {
+    return net::ERR_NOT_IMPLEMENTED;
+  }
+
   virtual bool CreateEntry(const std::string& key, disk_cache::Entry** entry) {
     if (fail_requests_)
       return false;
 
     EntryMap::iterator it = entries_.find(key);
     DCHECK(it == entries_.end());
 
     create_count_++;
 
     MockDiskEntry* new_entry = new MockDiskEntry(key);
 
     new_entry->AddRef();
     entries_[key] = new_entry;
 
     new_entry->AddRef();
     *entry = new_entry;
 
     if (soft_failures_)
       new_entry->set_fail_requests();
 
     return true;
   }
 
+  virtual int CreateEntry(const std::string& key, disk_cache::Entry** entry,
+                          net::CompletionCallback* callback) {
+    return net::ERR_NOT_IMPLEMENTED;
+  }
+
   virtual bool DoomEntry(const std::string& key) {
     EntryMap::iterator it = entries_.find(key);
     if (it != entries_.end()) {
       it->second->Release();
       entries_.erase(it);
     }
     return true;
   }
 
   virtual bool DoomAllEntries() {
     return false;
   }
 
+  virtual int DoomAllEntries(net::CompletionCallback* callback) {
+    return net::ERR_NOT_IMPLEMENTED;
+  }
+
   virtual bool DoomEntriesBetween(const Time initial_time,
                                   const Time end_time) {
     return true;
   }
 
+  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) {
     return true;
   }
 
+  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) {
     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) {
   }
 
   // returns number of times a cache entry was successfully opened
   int open_count() const { return open_count_; }
 
   // returns number of times a cache entry was successfully created
@@ skipping 3017 matching lines @@
   std::string headers;
   response.headers->GetNormalizedHeaders(&headers);
 
   EXPECT_EQ("HTTP/1.1 200 OK\n"
             "Date: Wed, 22 Jul 2009 03:15:26 GMT\n"
             "Last-Modified: Wed, 06 Feb 2008 22:38:21 GMT\n",
             headers);
 
   RemoveMockTransaction(&mock_network_response);
 }