URLRequestContext and disk cache for media files

net/disk_cache/disk_cache.h

 // 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.
 
 // Defines the public interface of the disk cache. For more details see
 // http://wiki/Main/ChromeDiskCacheBackend
 
 #ifndef NET_DISK_CACHE_DISK_CACHE_H__
 #define NET_DISK_CACHE_DISK_CACHE_H__
 
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
+#include "base/platform_file.h"
 #include "base/time.h"
 #include "net/base/completion_callback.h"
 
 namespace net {
 class IOBuffer;
 }
 
 namespace disk_cache {
 
 class Entry;
@@ skipping 121 matching lines @@
   // Note that the callback will be invoked in any case, even after Close has
   // been called; in other words, the caller may close this entry without
   // having to wait for all the callbacks, and still rely on the cleanup
   // performed from the callback code.
   // If truncate is true, this call will truncate the stored data at the end of
   // what we are writing here.
   virtual int WriteData(int index, int offset, net::IOBuffer* buf, int buf_len,
                         net::CompletionCallback* completion_callback,
                         bool truncate) = 0;
 
+  // Prepares a target stream as an external file, returns a corresponding
+  // base::PlatformFile if successful, returns base::kInvalidPlatformFileValue
+  // if fails. If this call returns a valid base::PlatformFile value (i.e.
+  // not base::kInvalidPlatformFileValue), there is no guarantee that the file
+  // is truncated. Implementor can always return base::kInvalidPlatformFileValue
+  // if external file is not available in that particular implementation.
+  // Caller should never close the file handle returned by this method, since
+  // the handle should be managed by the implementor of this class. Caller
+  // should never save the handle for future use.
+  // With a stream prepared as an external file, the stream would always be
+  // kept in an external file since creation, even if the stream has 0 bytes.
+  // So we need to be cautious about using this option for preparing a stream or
+  // we will end up having a lot of empty cache files. Calling this method also
+  // means that all data written to the stream will always be written to file
+  // directly *without* buffering.
+  virtual base::PlatformFile UseExternalFile(int index) = 0;
+
+  // Returns a read file handle for the cache stream referenced by |index|.
+  // Caller should never close the handle returned by this method and should
+  // not save it for future use. The lifetime of the base::PlatformFile handle
+  // is managed by the implementor of this class.
+  virtual base::PlatformFile GetPlatformFile(int index) = 0;
+
  protected:
   virtual ~Entry() {}
 };
 
 }  // namespace disk_cache
 
 #endif  // NET_DISK_CACHE_DISK_CACHE_H__