Remove code path that passes a file handle to the renderer...

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"
 
@@ skipping 569 matching lines @@
   if (cache_->mode() == PLAYBACK)
     effective_load_flags_ |= LOAD_ONLY_FROM_CACHE;
 
   // When in record mode, we want to NEVER load from the cache.
   // The reason for this is beacuse we save the Set-Cookie headers
   // (intentionally).  If we read from the cache, we replay them
   // prematurely.
   if (cache_->mode() == RECORD)
     effective_load_flags_ |= LOAD_BYPASS_CACHE;
 
-  // If HttpCache has type MEDIA make sure LOAD_ENABLE_DOWNLOAD_FILE is set,
-  // otherwise make sure LOAD_ENABLE_DOWNLOAD_FILE is not set when HttpCache
-  // has type other than MEDIA.
-  if (cache_->type() == MEDIA_CACHE) {
-    DCHECK(effective_load_flags_ & LOAD_ENABLE_DOWNLOAD_FILE);
-  } else {
-    DCHECK(!(effective_load_flags_ & LOAD_ENABLE_DOWNLOAD_FILE));
-  }
-
   // Some headers imply load flags.  The order here is significant.
   //
   //   LOAD_DISABLE_CACHE   : no cache read or write
   //   LOAD_BYPASS_CACHE    : no cache read
   //   LOAD_VALIDATE_CACHE  : no cache read unless validation
   //
   // The former modes trump latter modes, so if we find a matching header we
   // can stop iterating kSpecialHeaders.
   //
   static const struct {
@@ skipping 170 matching lines @@
   }
 
   return true;
 }
 
 int HttpCache::Transaction::ReadResponseInfoFromEntry() {
   DCHECK(entry_);
 
   if (!HttpCache::ReadResponseInfo(entry_->disk_entry, &response_))
     return ERR_CACHE_READ_FAILURE;
-
-  // If the cache object is used for media file, we want the file handle of
-  // response data.
-  if (cache_->type() == MEDIA_CACHE) {
-    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 40 matching lines @@
     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() == MEDIA_CACHE) {
-    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
@@ skipping 607 matching lines @@
     return;  // have to wait
 
   entry->pending_queue.erase(entry->pending_queue.begin());
 
   AddTransactionToEntry(entry, next);
 }
 
 //-----------------------------------------------------------------------------
 
 }  // namespace net