URLRequestContext and disk cache for media files

net/disk_cache/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/entry_impl.h"
 
 #include "base/histogram.h"
 #include "base/message_loop.h"
 #include "base/string_util.h"
 #include "net/base/io_buffer.h"
@@ skipping 60 matching lines @@
 
 }  // namespace
 
 namespace disk_cache {
 
 EntryImpl::EntryImpl(BackendImpl* backend, Addr address)
     : entry_(NULL, Addr(0)), node_(NULL, Addr(0)) {
   entry_.LazyInit(backend->File(address), address);
   doomed_ = false;
   backend_ = backend;
-  for (int i = 0; i < NUM_STREAMS; i++)
+  for (int i = 0; i < NUM_STREAMS; i++) {
     unreported_size_[i] = 0;
+    need_file_[i] = false;
+  }
 }
 
 // When an entry is deleted from the cache, we clean up all the data associated
 // with it for two reasons: to simplify the reuse of the block (we know that any
 // unused block is filled with zeros), and to simplify the handling of write /
 // read partial information from an entry (don't have to worry about returning
 // data related to a previous cache entry because the range was not fully
 // written before).
 EntryImpl::~EntryImpl() {
   if (doomed_) {
@@ skipping 218 matching lines @@
       } else {
         // Nothing to truncate.
         truncate = false;
       }
   }
 
   UpdateRank(true);
 
   backend_->OnEvent(Stats::WRITE_DATA);
 
-  if (user_buffers_[index].get()) {
+  // If we have prepared the cache as an external file, we should never use
+  // user_buffers_ and always write to file directly.
+  if (!need_file_[index] && user_buffers_[index].get()) {
     // Complete the operation locally.
     if (!buf_len)
       return 0;
 
     DCHECK(kMaxBlockSize >= offset + buf_len);
     memcpy(user_buffers_[index].get() + offset, buf->data(), buf_len);
     stats.AddTime(Time::Now() - start);
     return buf_len;
   }
 
@@ skipping 26 matching lines @@
     return net::ERR_FAILED;
   }
 
   if (io_callback && completed)
     io_callback->Discard();
 
   stats.AddTime(Time::Now() - start);
   return (completed || !completion_callback) ? buf_len : net::ERR_IO_PENDING;
 }
 
+base::PlatformFile EntryImpl::UseExternalFile(int index) {
+  DCHECK(index >= 0 && index < NUM_STREAMS);
+
+  Addr address(entry_.Data()->data_addr[index]);
+
+  // We will not prepare the cache file since the entry is already initialized,
+  // just return the platform file backing the cache.
+  if (address.is_initialized())
+    return GetPlatformFile(index);
+
+  if (!backend_->CreateExternalFile(&address))
+    return base::kInvalidPlatformFileValue;
+
+  entry_.Data()->data_addr[index] = address.value();
+  entry_.Store();
+
+  // Set the flag for this stream so we never use user_buffer_.
+  // TODO(hclam): do we need to save this information to EntryStore?
+  need_file_[index] = true;
+
+  return GetPlatformFile(index);
+}
+
+base::PlatformFile EntryImpl::GetPlatformFile(int index) {
+  DCHECK(index >= 0 && index < NUM_STREAMS);
+
+  Addr address(entry_.Data()->data_addr[index]);
+  if (!address.is_initialized() || !address.is_separate_file())
+    return base::kInvalidPlatformFileValue;
+
+  File* cache_file = GetExternalFile(address, index);
+  if (!cache_file)
+    return base::kInvalidPlatformFileValue;
+
+  return cache_file->platform_file();
+}
+
 uint32 EntryImpl::GetHash() {
   return entry_.Data()->hash;
 }
 
 bool EntryImpl::CreateEntry(Addr node_address, const std::string& key,
                             uint32 hash) {
   Trace("Create entry In");
   EntryStore* entry_store = entry_.Data();
   RankingsNode* node = node_.Data();
   memset(entry_store, 0, sizeof(EntryStore) * entry_.address().num_blocks());
@@ skipping 218 matching lines @@
     scoped_refptr<File> file(new File(kKeyFileIndex == index));
     if (file->Init(backend_->GetFileName(address)))
       files_[index].swap(file);
   }
   return files_[index].get();
 }
 
 bool EntryImpl::PrepareTarget(int index, int offset, int buf_len,
                               bool truncate) {
   Addr address(entry_.Data()->data_addr[index]);
+
+  // If we are instructed to use an external file, we should never buffer when
+  // writing. We are done with preparation of the target automatically, since
+  // we have already created the external file for writing.
+  if (need_file_[index]) {
+    // Make sure the stream is initialized and is kept in an external file.
+    DCHECK(address.is_initialized() && address.is_separate_file());
+    return true;
+  }
+
   if (address.is_initialized() || user_buffers_[index].get())
     return GrowUserBuffer(index, offset, buf_len, truncate);
 
   if (offset + buf_len > kMaxBlockSize)
     return CreateDataBlock(index, offset + buf_len);
 
   user_buffers_[index].reset(new char[kMaxBlockSize]);
 
   // Overwrite the parts of the buffer that are not going to be written
   // by the current operation (and yes, let's assume that nothing is going
@@ skipping 162 matching lines @@
   Trace("%s 0x%p 0x%x 0x%x", msg, reinterpret_cast<void*>(this),
         entry_.address().value(), node_.address().value());
 
   Trace("  data: 0x%x 0x%x 0x%x", entry_.Data()->data_addr[0],
         entry_.Data()->data_addr[1], entry_.Data()->long_key);
 
   Trace("  doomed: %d 0x%p 0x%x", doomed_, pointer, dirty);
 }
 
 }  // namespace disk_cache