IPC messages and changes to ResourceLoaderBridge to support resource loading for media

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"
+
+#if defined(OS_POSIX)
+#include <unistd.h>
+#endif
+
 #include "base/message_loop.h"
 #include "base/pickle.h"
 #include "base/ref_counted.h"
 #include "base/string_util.h"
 #include "base/time.h"
 #include "net/base/io_buffer.h"
 #include "net/base/load_flags.h"
 #include "net/base/net_errors.h"
 #include "net/disk_cache/disk_cache.h"
 #include "net/http/http_network_layer.h"
@@ skipping 580 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() == HttpCache::MEDIA) {
+    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 169 matching lines @@
 }
 
 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)
+  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,
@@ skipping 50 matching lines @@
 
   // 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)
+  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)
@@ skipping 567 matching lines @@
     return;  // have to wait
 
   entry->pending_queue.erase(entry->pending_queue.begin());
 
   AddTransactionToEntry(entry, next);
 }
 
 //-----------------------------------------------------------------------------
 
 }  // namespace net