Disk cache: Add support for an extra data stream for each cache entry....

net/disk_cache/mem_entry_impl.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/disk_cache/mem_entry_impl.h"
 
 #include "net/base/net_errors.h"
 #include "net/disk_cache/mem_backend_impl.h"
 
 using base::Time;
 
 namespace disk_cache {
 
 MemEntryImpl::MemEntryImpl(MemBackendImpl* backend) {
   doomed_ = false;
   backend_ = backend;
   ref_count_ = 0;
-  data_size_[0] = data_size_[1] = 0;
+  for (int i = 0; i < NUM_STREAMS; i++)
+    data_size_[i] = 0;
 }
 
 MemEntryImpl::~MemEntryImpl() {
-  backend_->ModifyStorageSize(data_size_[0], 0);
-  backend_->ModifyStorageSize(data_size_[1], 0);
+  for (int i = 0; i < NUM_STREAMS; i++)
+    backend_->ModifyStorageSize(data_size_[i], 0);
   backend_->ModifyStorageSize(static_cast<int32>(key_.size()), 0);
 }
 
 bool MemEntryImpl::CreateEntry(const std::string& key) {
   key_ = key;
   last_modified_ = Time::Now();
   last_used_ = Time::Now();
   Open();
   backend_->ModifyStorageSize(0, static_cast<int32>(key.size()));
   return true;
@@ skipping 34 matching lines @@
 
 Time MemEntryImpl::GetLastUsed() const {
   return last_used_;
 }
 
 Time MemEntryImpl::GetLastModified() const {
   return last_modified_;
 }
 
 int32 MemEntryImpl::GetDataSize(int index) const {
-  if (index < 0 || index > 1)
+  if (index < 0 || index >= NUM_STREAMS)
     return 0;
 
   return data_size_[index];
 }
 
 int MemEntryImpl::ReadData(int index, int offset, char* buf, int buf_len,
                            net::CompletionCallback* completion_callback) {
-  if (index < 0 || index > 1)
+  if (index < 0 || index >= NUM_STREAMS)
     return net::ERR_INVALID_ARGUMENT;
 
   int entry_size = GetDataSize(index);
   if (offset >= entry_size || offset < 0 || !buf_len)
     return 0;
 
   if (buf_len < 0)
     return net::ERR_INVALID_ARGUMENT;
 
   if (offset + buf_len > entry_size)
     buf_len = entry_size - offset;
 
   UpdateRank(false);
 
   memcpy(buf , &(data_[index])[offset], buf_len);
   return buf_len;
 }
 
 int MemEntryImpl::WriteData(int index, int offset, const char* buf, int buf_len,
                          net::CompletionCallback* completion_callback,
                          bool truncate) {
-  if (index < 0 || index > 1)
+  if (index < 0 || index >= NUM_STREAMS)
     return net::ERR_INVALID_ARGUMENT;
 
   if (offset < 0 || buf_len < 0)
     return net::ERR_INVALID_ARGUMENT;
 
   int max_file_size = backend_->MaxFileSize();
 
   // offset of buf_len could be negative numbers.
   if (offset > max_file_size || buf_len > max_file_size ||
       offset + buf_len > max_file_size) {
@@ skipping 50 matching lines @@
 
   if (modified)
     last_modified_ = current;
 
   if (!doomed_)
     backend_->UpdateRank(this);
 }
 
 }  // namespace disk_cache