URLRequestContext and disk cache for media files

net/http/http_cache_unittest.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 "base/hash_tables.h"
 #include "base/message_loop.h"
+#include "base/platform_file.h"
 #include "base/string_util.h"
 #include "net/base/net_errors.h"
 #include "net/base/load_flags.h"
 #include "net/disk_cache/disk_cache.h"
 #include "net/http/http_request_info.h"
 #include "net/http/http_response_info.h"
 #include "net/http/http_transaction.h"
 #include "net/http/http_transaction_unittest.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::Time;
 
 namespace {
 
 //-----------------------------------------------------------------------------
 // mock disk cache (a very basic memory cache implementation)
 
 class MockDiskEntry : public disk_cache::Entry,
                       public base::RefCounted<MockDiskEntry> {
  public:
-  MockDiskEntry() : test_mode_(0), doomed_(false) {
+  MockDiskEntry()
+      : test_mode_(0), doomed_(false), platform_file_(global_platform_file_) {
   }
 
-  MockDiskEntry(const std::string& key) : key_(key), doomed_(false) {
+  MockDiskEntry(const std::string& key)
+      : key_(key), doomed_(false), platform_file_(global_platform_file_) {
     const MockTransaction* t = FindMockTransaction(GURL(key));
     DCHECK(t);
     test_mode_ = t->test_mode;
   }
 
   ~MockDiskEntry() {
   }
 
   bool is_doomed() const { return doomed_; }
 
@@ skipping 48 matching lines @@
 
     if (offset < 0 || offset > static_cast<int>(data_[index].size()))
       return net::ERR_FAILED;
 
     data_[index].resize(offset + buf_len);
     if (buf_len)
       memcpy(&data_[index][offset], buf->data(), buf_len);
     return buf_len;
   }
 
+  base::PlatformFile UseExternalFile(int index) {
+    return platform_file_;
+  }
+
+  base::PlatformFile GetPlatformFile(int index) {
+    return platform_file_;
+  }
+
+  static void set_global_platform_file(base::PlatformFile platform_file) {
+    global_platform_file_ = platform_file;
+  }
+
  private:
   // Unlike the callbacks for MockHttpTransaction, we want this one to run even
   // if the consumer called Close on the MockDiskEntry.  We achieve that by
   // leveraging the fact that this class is reference counted.
   void CallbackLater(net::CompletionCallback* callback, int result) {
     MessageLoop::current()->PostTask(FROM_HERE, NewRunnableMethod(this,
         &MockDiskEntry::RunCallback, callback, result));
   }
   void RunCallback(net::CompletionCallback* callback, int result) {
     callback->Run(result);
   }
 
   std::string key_;
   std::vector<char> data_[2];
   int test_mode_;
   bool doomed_;
+  base::PlatformFile platform_file_;
+  static base::PlatformFile global_platform_file_;
 };
 
+base::PlatformFile MockDiskEntry::global_platform_file_ =
+    base::kInvalidPlatformFileValue;
+
 class MockDiskCache : public disk_cache::Backend {
  public:
   MockDiskCache() : open_count_(0), create_count_(0), fail_requests_(0) {
   }
 
   ~MockDiskCache() {
     EntryMap::iterator it = entries_.begin();
     for (; it != entries_.end(); ++it)
       it->second->Release();
   }
@@ skipping 1048 matching lines @@
 }
 
 // Ensure that we don't crash by if left-behind transactions.
 TEST(HttpCache, OutlivedTransactions) {
   MockHttpCache* cache = new MockHttpCache;
 
   net::HttpTransaction* trans = cache->http_cache()->CreateTransaction();
   delete cache;
   delete trans;
 }
+
+// Make sure Entry::UseExternalFile is called when a new entry is created in
+// a HttpCache with MEDIA type. Also make sure Entry::GetPlatformFile is called
+// when an entry is loaded from a HttpCache with MEDIA type. Also confirm we
+// will receive a file handle in ResponseInfo from a media cache.
+TEST(HttpCache, SimpleGET_MediaCache) {
+  // Initialize the HttpCache with MEDIA type.
+  MockHttpCache cache;
+  cache.http_cache()->set_type(net::HttpCache::MEDIA);
+
+  // Define some fake file handles for testing.
+  base::PlatformFile kFakePlatformFile1, kFakePlatformFile2;
+#if defined(OS_WIN)
+  kFakePlatformFile1 = reinterpret_cast<base::PlatformFile>(1);
+  kFakePlatformFile2 = reinterpret_cast<base::PlatformFile>(2);
+#else
+  kFakePlatformFile1 = 1;
+  kFakePlatformFile2 = 2;
+#endif
+
+  ScopedMockTransaction trans_info(kSimpleGET_Transaction);
+  TestCompletionCallback callback;
+
+  {
+    // Set the fake file handle to MockDiskEntry so cache is written with an
+    // entry created with our fake file handle.
+    MockDiskEntry::set_global_platform_file(kFakePlatformFile1);
+
+    scoped_ptr<net::HttpTransaction> trans(
+        cache.http_cache()->CreateTransaction());
+    ASSERT_TRUE(trans.get());
+
+    MockHttpRequest request(trans_info);
+
+    int rv = trans->Start(&request, &callback);
+    if (rv == net::ERR_IO_PENDING)
+      rv = callback.WaitForResult();
+    ASSERT_EQ(net::OK, rv);
+
+    const net::HttpResponseInfo* response = trans->GetResponseInfo();
+    ASSERT_TRUE(response);
+
+    ASSERT_EQ(kFakePlatformFile1, response->response_data_file);
+
+    ReadAndVerifyTransaction(trans.get(), trans_info);
+  }
+
+  // Load only from cache so we would get the same file handle.
+  trans_info.load_flags |= net::LOAD_ONLY_FROM_CACHE;
+
+  {
+    // Set a different file handle value to MockDiskEntry so any new entry
+    // created in the cache won't have the same file handle value.
+    MockDiskEntry::set_global_platform_file(kFakePlatformFile2);
+
+    scoped_ptr<net::HttpTransaction> trans(
+        cache.http_cache()->CreateTransaction());
+    ASSERT_TRUE(trans.get());
+
+    MockHttpRequest request(trans_info);
+
+    int rv = trans->Start(&request, &callback);
+    if (rv == net::ERR_IO_PENDING)
+      rv = callback.WaitForResult();
+    ASSERT_EQ(net::OK, rv);
+
+    const net::HttpResponseInfo* response = trans->GetResponseInfo();
+    ASSERT_TRUE(response);
+
+    // Make sure we get the same file handle as in the first request.
+    ASSERT_EQ(kFakePlatformFile1, response->response_data_file);
+
+    ReadAndVerifyTransaction(trans.get(), trans_info);
+  }
+}