This makes net_perftests build and run on Linux.

net/disk_cache/disk_cache_perftest.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 <fcntl.h>
+#include <unistd.h>
+
+#include <string>
+
+#include "base/basictypes.h"
 #include "base/file_util.h"
 #include "base/perftimer.h"
+#if defined(OS_WIN)
 #include "base/scoped_handle.h"
+#endif
+#include "base/string_util.h"
 #include "base/timer.h"
 #include "net/base/net_errors.h"
 #include "net/disk_cache/block_files.h"
 #include "net/disk_cache/disk_cache.h"
 #include "net/disk_cache/disk_cache_test_base.h"
 #include "net/disk_cache/disk_cache_test_util.h"
 #include "net/disk_cache/hash.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 extern int g_cache_tests_max_id;
 extern volatile int g_cache_tests_received;
 extern volatile bool g_cache_tests_error;
 
 namespace {
 
 bool EvictFileFromSystemCache(const wchar_t* name) {
+#if defined(OS_WIN)
   // Overwrite it with no buffering.
   ScopedHandle file(CreateFile(name, GENERIC_READ | GENERIC_WRITE,
                                FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
                                OPEN_EXISTING, FILE_FLAG_NO_BUFFERING, NULL));
   if (!file.IsValid())
     return false;
 
   // Execute in chunks. It could be optimized. We want to do few of these since
   // these opterations will be slow without the cache.
   char buffer[128 * 1024];
@@ skipping 17 matching lines @@
       return false;
     total_bytes += bytes_read;
 
     if (final) {
       SetFilePointer(file, total_bytes, 0, FILE_BEGIN);
       SetEndOfFile(file);
       break;
     }
   }
   return true;
+#elif defined(OS_LINUX)
+  int fd = open(WideToUTF8(std::wstring(name)).c_str(), O_RDONLY);
+  if (fd < 0)
+    return false;
+  if (fdatasync(fd) != 0)
+    return false;
+  if (posix_fadvise(fd, 0, 0, POSIX_FADV_DONTNEED) != 0)
+    return false;
+  close(fd);
+  return true;
+#else
+  // TODO(port): Mac has its own way to do this.
+  NOTIMPLEMENTED();
+  return false;
+#endif
 }
 
 struct TestEntry {
   std::string key;
   int data_len;
 };
 typedef std::vector<TestEntry> TestEntries;
 
 const int kMaxSize = 16 * 1024 - 1;
 
@@ skipping 100 matching lines @@
 
 }  // namespace
 
 TEST_F(DiskCacheTest, Hash) {
   int seed = static_cast<int>(Time::Now().ToInternalValue());
   srand(seed);
 
   PerfTimeLogger timer("Hash disk cache keys");
   for (int i = 0; i < 300000; i++) {
     std::string key = GenerateKey(true);
-    uint32 hash = disk_cache::Hash(key);
+    disk_cache::Hash(key);
   }
   timer.Done();
 }
 
 TEST_F(DiskCacheTest, CacheBackendPerformance) {
   MessageLoopForIO message_loop;
 
   std::wstring path = GetCachePath();
   ASSERT_TRUE(DeleteCache(path.c_str()));
   disk_cache::Backend* cache = disk_cache::CreateCacheBackend(path, false, 0);
@@ skipping 79 matching lines @@
     if (entry >= kNumEntries)
       entry = 0;
 
     files.DeleteBlock(address[entry], false);
     EXPECT_TRUE(files.CreateBlock(disk_cache::RANKINGS, BlockSize(),
                                   &address[entry]));
   }
 
   timer2.Done();
 }