URLRequestContext and disk cache for media files

net/http/http_cache.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 <algorithm>
 
 #include "base/compiler_specific.h"
 #include "base/message_loop.h"
@@ skipping 268 matching lines @@
   int ReadResponseInfoFromEntry();
 
   // Called to write data to the cache entry.  If the write fails, then the
   // cache entry is destroyed.  Future calls to this function will just do
   // nothing without side-effect.
   void WriteToEntry(int index, int offset, IOBuffer* data, int data_len);
 
   // Called to write response_ to the cache entry.
   void WriteResponseInfoToEntry();
 
+  // Called to truncate response content in the entry.
+  void TruncateResponseData();
+
   // Called to append response data to the cache entry.
   void AppendResponseDataToEntry(IOBuffer* data, int data_len);
 
   // Called when we are done writing to the cache entry.
   void DoneWritingToEntry(bool success);
 
   // Called to signal completion of the network transaction's Start method:
   void OnNetworkInfoAvailable(int result);
 
   // Called to signal completion of the network transaction's Read method:
@@ skipping 484 matching lines @@
 
   return true;
 }
 
 int HttpCache::Transaction::ReadResponseInfoFromEntry() {
   DCHECK(entry_);
 
   if (!HttpCache::ReadResponseInfo(entry_->disk_entry, &response_))
     return ERR_FAILED;
 
+  // If the cache object is used for media file, we want the file handle of
+  // response data.
+  if (cache_->type() == HttpCache::MEDIA)
+    response_.response_data_file =
+        entry_->disk_entry->GetPlatformFile(kResponseContentIndex);
+
   return OK;
 }
 
 void HttpCache::Transaction::WriteToEntry(int index, int offset,
                                           IOBuffer* data, int data_len) {
   if (!entry_)
     return;
 
   int rv = entry_->disk_entry->WriteData(index, offset, data, data_len, NULL,
                                          true);
@@ skipping 36 matching lines @@
 
 void HttpCache::Transaction::AppendResponseDataToEntry(IOBuffer* data,
                                                        int data_len) {
   if (!entry_)
     return;
 
   int current_size = entry_->disk_entry->GetDataSize(kResponseContentIndex);
   WriteToEntry(kResponseContentIndex, current_size, data, data_len);
 }
 
+void HttpCache::Transaction::TruncateResponseData() {
+  if (!entry_)
+    return;
+
+  // If the cache is for media files, we try to prepare the response data
+  // file as an external file and truncate it afterwards.
+  // Recipient of ResponseInfo should judge from |response_.response_data_file|
+  // to tell whether an external file of response data is available for reading
+  // or not.
+  // TODO(hclam): we should prepare the target stream as extern file only
+  // if we get a valid response from server, i.e. 200. We don't want empty
+  // cache files for redirection or external files for erroneous requests.
+  response_.response_data_file = base::kInvalidPlatformFileValue;
+  if (cache_->type() == HttpCache::MEDIA)
+    response_.response_data_file =
+        entry_->disk_entry->UseExternalFile(kResponseContentIndex);
+
+  // Truncate the stream.
+  WriteToEntry(kResponseContentIndex, 0, NULL, 0);
+}
+
 void HttpCache::Transaction::DoneWritingToEntry(bool success) {
   if (!entry_)
     return;
 
   if (cache_->mode() == RECORD)
     DLOG(INFO) << "Recorded: " << request_->method << request_->url
                << " status: " << response_.headers->response_code();
 
   cache_->DoneWritingToEntry(entry_, success);
   entry_ = NULL;
@@ skipping 36 matching lines @@
           }
         } else {
           mode_ = WRITE;
         }
       }
 
       if (!(mode_ & READ)) {
         response_ = *new_response;
         WriteResponseInfoToEntry();
 
-        // Truncate the response data
-        WriteToEntry(kResponseContentIndex, 0, NULL, 0);
+        // Truncate response data
+        TruncateResponseData();
 
         // If this response is a redirect, then we can stop writing now.  (We
         // don't need to cache the response body of a redirect.)
         if (response_.headers->IsRedirect(NULL))
           DoneWritingToEntry(true);
       }
     }
   } else if (IsCertificateError(result)) {
     response_.ssl_info = network_trans_->GetResponseInfo()->ssl_info;
   }
@@ skipping 34 matching lines @@
   HandleResult(result);
 }
 
 //-----------------------------------------------------------------------------
 
 HttpCache::HttpCache(ProxyService* proxy_service,
                      const std::wstring& cache_dir,
                      int cache_size)
     : disk_cache_dir_(cache_dir),
       mode_(NORMAL),
+      type_(COMMON),
       network_layer_(HttpNetworkLayer::CreateFactory(proxy_service)),
       ALLOW_THIS_IN_INITIALIZER_LIST(task_factory_(this)),
       in_memory_cache_(false),
       cache_size_(cache_size) {
 }
 
+HttpCache::HttpCache(HttpNetworkSession* session,
+                     const std::wstring& cache_dir,
+                     int cache_size)
+    : disk_cache_dir_(cache_dir),
+      mode_(NORMAL),
+      type_(COMMON),
+      network_layer_(HttpNetworkLayer::CreateFactory(session)),
+      ALLOW_THIS_IN_INITIALIZER_LIST(task_factory_(this)),
+      in_memory_cache_(false),
+      cache_size_(cache_size) {
+}
+
 HttpCache::HttpCache(ProxyService* proxy_service, int cache_size)
     : mode_(NORMAL),
+      type_(COMMON),
       network_layer_(HttpNetworkLayer::CreateFactory(proxy_service)),
       ALLOW_THIS_IN_INITIALIZER_LIST(task_factory_(this)),
       in_memory_cache_(true),
       cache_size_(cache_size) {
 }
 
 HttpCache::HttpCache(HttpTransactionFactory* network_layer,
                      disk_cache::Backend* disk_cache)
     : mode_(NORMAL),
+      type_(COMMON),
       network_layer_(network_layer),
       disk_cache_(disk_cache),
       ALLOW_THIS_IN_INITIALIZER_LIST(task_factory_(this)),
       in_memory_cache_(false),
       cache_size_(0) {
 }
 
 HttpCache::~HttpCache() {
   // If we have any active entries remaining, then we need to deactivate them.
   // We may have some pending calls to OnProcessPendingQueue, but since those
@@ skipping 419 matching lines @@
 
   entry->pending_queue.erase(entry->pending_queue.begin());
 
   AddTransactionToEntry(entry, next);
 }
 
 //-----------------------------------------------------------------------------
 
 }  // namespace net