Port flush_cache tool.

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 <string>
 
 #include "base/basictypes.h"
+#include "base/file_path.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/test_file_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_util.h"
 #include "net/disk_cache/hash.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/platform_test.h"
 
 using base::Time;
 
 extern int g_cache_tests_max_id;
 extern volatile int g_cache_tests_received;
 extern volatile bool g_cache_tests_error;
 
 typedef PlatformTest DiskCacheTest;
 
 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];
-  int total_bytes = 0;
-  DWORD bytes_read;
-  for (;;) {
-    if (!ReadFile(file, buffer, sizeof(buffer), &bytes_read, NULL))
-      return false;
-    if (bytes_read == 0)
-      break;
-
-    bool final = false;
-    if (bytes_read < sizeof(buffer))
-      final = true;
-
-    DWORD to_write = final ? sizeof(buffer) : bytes_read;
-
-    DWORD actual;
-    SetFilePointer(file, total_bytes, 0, FILE_BEGIN);
-    if (!WriteFile(file, buffer, to_write, &actual, NULL))
-      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;
 
 // Creates num_entries on the cache, and writes 200 bytes of metadata and up
 // to kMaxSize of data to each entry.
@@ skipping 106 matching lines @@
   for (int i = 0; i < 300000; i++) {
     std::string key = GenerateKey(true);
     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);
+  std::wstring path_wstring = GetCachePath();
+  ASSERT_TRUE(DeleteCache(path_wstring.c_str()));
+  disk_cache::Backend* cache = disk_cache::CreateCacheBackend(path_wstring,
+                                                              false, 0);
   ASSERT_TRUE(NULL != cache);
 
   int seed = static_cast<int>(Time::Now().ToInternalValue());
   srand(seed);
 
   TestEntries entries;
   int num_entries = 1000;
 
   int ret = TimeWrite(num_entries, cache, &entries);
   EXPECT_EQ(ret, g_cache_tests_received);
 
   MessageLoop::current()->RunAllPending();
   delete cache;
 
-  std::wstring filename(path);
-  file_util::AppendToPath(&filename, L"index");
-  ASSERT_TRUE(EvictFileFromSystemCache(filename.c_str()));
+  FilePath path = FilePath::FromWStringHack(path_wstring);
 
-  filename = path;
-  file_util::AppendToPath(&filename, L"data_0");
-  ASSERT_TRUE(EvictFileFromSystemCache(filename.c_str()));
+  ASSERT_TRUE(file_util::EvictFileFromSystemCache(
+              path.Append(FILE_PATH_LITERAL("index"))));
+  ASSERT_TRUE(file_util::EvictFileFromSystemCache(
+              path.Append(FILE_PATH_LITERAL("data_0"))));
+  ASSERT_TRUE(file_util::EvictFileFromSystemCache(
+              path.Append(FILE_PATH_LITERAL("data_1"))));
+  ASSERT_TRUE(file_util::EvictFileFromSystemCache(
+              path.Append(FILE_PATH_LITERAL("data_2"))));
+  ASSERT_TRUE(file_util::EvictFileFromSystemCache(
+              path.Append(FILE_PATH_LITERAL("data_3"))));
 
-  filename = path;
-  file_util::AppendToPath(&filename, L"data_1");
-  ASSERT_TRUE(EvictFileFromSystemCache(filename.c_str()));
-
-  filename = path;
-  file_util::AppendToPath(&filename, L"data_2");
-  ASSERT_TRUE(EvictFileFromSystemCache(filename.c_str()));
-
-  filename = path;
-  file_util::AppendToPath(&filename, L"data_3");
-  ASSERT_TRUE(EvictFileFromSystemCache(filename.c_str()));
-
-  cache = disk_cache::CreateCacheBackend(path, false, 0);
+  cache = disk_cache::CreateCacheBackend(path_wstring, false, 0);
   ASSERT_TRUE(NULL != cache);
 
   ret = TimeRead(num_entries, cache, entries, true);
   EXPECT_EQ(ret, g_cache_tests_received);
 
   ret = TimeRead(num_entries, cache, entries, false);
   EXPECT_EQ(ret, g_cache_tests_received);
 
   MessageLoop::current()->RunAllPending();
   delete cache;
@@ skipping 38 matching lines @@
       entry = 0;
 
     files.DeleteBlock(address[entry], false);
     EXPECT_TRUE(files.CreateBlock(disk_cache::RANKINGS, BlockSize(),
                                   &address[entry]));
   }
 
   timer2.Done();
   MessageLoop::current()->RunAllPending();
 }