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

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), platform_file_(global_platform_file_) {
+      : test_mode_(0), doomed_(false) {
   }
 
   MockDiskEntry(const std::string& key)
-      : key_(key), doomed_(false), platform_file_(global_platform_file_) {
+      : key_(key), doomed_(false) {
     //
     // 'key' is prefixed with an identifier if it corresponds to a cached POST.
     // Skip past that to locate the actual URL.
     //
     // TODO(darin): It breaks the abstraction a bit that we assume 'key' is an
     // URL corresponding to a registered MockTransaction.  It would be good to
     // have another way to access the test_mode.
     //
     GURL url;
     if (isdigit(key[0])) {
@@ skipping 64 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 1085 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_CACHE type.
-  MockHttpCache cache;
-  cache.http_cache()->set_type(net::MEDIA_CACHE);
-
-  // 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);
-  trans_info.load_flags |= net::LOAD_ENABLE_DOWNLOAD_FILE;
-  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);
-  }
-}