Disk cache: Interface for the sparse cache support....

net/http/http_cache_unittest.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/http/http_cache.h"
 
 #include "base/hash_tables.h"
 #include "base/message_loop.h"
 #include "base/string_util.h"
 #include "net/base/net_errors.h"
 #include "net/base/load_flags.h"
 #include "net/disk_cache/disk_cache.h"
 #include "net/http/http_request_info.h"
 #include "net/http/http_response_info.h"
 #include "net/http/http_transaction.h"
 #include "net/http/http_transaction_unittest.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::Time;
 
 namespace {
 
 //-----------------------------------------------------------------------------
 // mock disk cache (a very basic memory cache implementation)
 
 class MockDiskEntry : public disk_cache::Entry,
                       public base::RefCounted<MockDiskEntry> {
  public:
   MockDiskEntry()
-      : test_mode_(0), doomed_(false) {
+      : test_mode_(0), doomed_(false), sparse_(false) {
   }
 
   MockDiskEntry(const std::string& key)
-      : key_(key), doomed_(false) {
+      : key_(key), doomed_(false), sparse_(false) {
     //
     // 'key' is prefixed with an identifier if it corresponds to a cached POST.
     // Skip past that to locate the actual URL.
     //
     // TODO(darin): It breaks the abstraction a bit that we assume 'key' is an
     // URL corresponding to a registered MockTransaction.  It would be good to
     // have another way to access the test_mode.
     //
     GURL url;
     if (isdigit(key[0])) {
@@ skipping 64 matching lines @@
 
     if (offset < 0 || offset > static_cast<int>(data_[index].size()))
       return net::ERR_FAILED;
 
     data_[index].resize(offset + buf_len);
     if (buf_len)
       memcpy(&data_[index][offset], buf->data(), buf_len);
     return buf_len;
   }
 
+  virtual int ReadSparseData(int64 offset, net::IOBuffer* buf, int buf_len,
+                             net::CompletionCallback* completion_callback) {
+    if (!sparse_)
+      return net::ERR_CACHE_OPERATION_NOT_SUPPORTED;
+    if (offset < 0)
+      return net::ERR_FAILED;
+
+    DCHECK(offset < kint32max);
+    int real_offset = static_cast<int>(offset);
+    if (!buf_len)
+      return 0;
+
+    int num = std::min(static_cast<int>(data_[1].size()) - real_offset,
+                       buf_len);
+    memcpy(buf->data(), &data_[1][real_offset], num);
+
+    if (!completion_callback || (test_mode_ & TEST_MODE_SYNC_CACHE_READ))
+      return num;
+
+    CallbackLater(completion_callback, num);
+    return net::ERR_IO_PENDING;
+  }
+
+  virtual int WriteSparseData(int64 offset, net::IOBuffer* buf, int buf_len,
+                              net::CompletionCallback* completion_callback) {
+    if (!sparse_) {
+      if (data_[1].size())
+        return net::ERR_CACHE_OPERATION_NOT_SUPPORTED;
+      sparse_ = true;
+    }
+    if (offset < 0)
+      return net::ERR_FAILED;
+    if (!buf_len)
+      return 0;
+
+    DCHECK(offset < kint32max);
+    int real_offset = static_cast<int>(offset);
+
+    if (static_cast<int>(data_[1].size()) < real_offset + buf_len)
+      data_[1].resize(real_offset + buf_len);
+
+    memcpy(&data_[1][real_offset], buf->data(), buf_len);
+    return buf_len;
+  }
+
+  virtual int GetAvailableRange(int64 offset, int len, int64* start) {
+    if (!sparse_)
+      return net::ERR_CACHE_OPERATION_NOT_SUPPORTED;
+    if (offset < 0)
+      return net::ERR_FAILED;
+
+    *start = offset;
+    DCHECK(offset < kint32max);
+    int real_offset = static_cast<int>(offset);
+    if (static_cast<int>(data_[1].size()) < real_offset)
+      return 0;
+
+    int num = std::min(static_cast<int>(data_[1].size()) - real_offset, len);
+    int count = 0;
+    for (; num > 0; num--, real_offset++) {
+      if (!count) {
+        if (data_[1][real_offset]) {
+          count++;
+          *start = real_offset;
+        }
+      } else {
+        if (!data_[1][real_offset])
+          break;
+        count++;
+      }
+    }
+    return count;
+  }
+
  private:
   // Unlike the callbacks for MockHttpTransaction, we want this one to run even
   // if the consumer called Close on the MockDiskEntry.  We achieve that by
   // leveraging the fact that this class is reference counted.
   void CallbackLater(net::CompletionCallback* callback, int result) {
     MessageLoop::current()->PostTask(FROM_HERE, NewRunnableMethod(this,
         &MockDiskEntry::RunCallback, callback, result));
   }
   void RunCallback(net::CompletionCallback* callback, int result) {
     callback->Run(result);
   }
 
   std::string key_;
   std::vector<char> data_[2];
   int test_mode_;
   bool doomed_;
+  bool sparse_;
 };
 
 class MockDiskCache : public disk_cache::Backend {
  public:
   MockDiskCache() : open_count_(0), create_count_(0), fail_requests_(0) {
   }
 
   ~MockDiskCache() {
     EntryMap::iterator it = entries_.begin();
     for (; it != entries_.end(); ++it)
@@ skipping 1087 matching lines @@
 }
 
 // Ensure that we don't crash by if left-behind transactions.
 TEST(HttpCache, OutlivedTransactions) {
   MockHttpCache* cache = new MockHttpCache;
 
   net::HttpTransaction* trans = cache->http_cache()->CreateTransaction();
   delete cache;
   delete trans;
 }