Add a PartialPreReadImage function to file_util (on Windows).

base/file_util_unittest.cc

 // Copyright (c) 2012 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 "build/build_config.h"
 
 #if defined(OS_WIN)
 #include <windows.h>
 #include <shellapi.h>
 #include <shlobj.h>
@@ skipping 651 matching lines @@
                    FILE_FLAG_BACKUP_SEMANTICS,  // Needed to open a directory.
                    NULL));
   ASSERT_TRUE(dir.IsValid());
   base::PlatformFileInfo info;
   EXPECT_TRUE(base::GetPlatformFileInfo(dir.Get(), &info));
   EXPECT_TRUE(info.is_directory);
   EXPECT_FALSE(info.is_symbolic_link);
   EXPECT_EQ(0, info.size);
 }
 
+// TODO(rogerm): Flesh out the *PreReadImage* tests to validate an observed
+//     change in paging behaviour between raw loading and pre-reading.
+
+// TODO(rogerm): Add checks to the *PreReadImage* tests to validate the
+//     handling of invalid pe files and paths as input.
+
+TEST_F(FileUtilTest, PreReadImage) {
+  using file_util::PreReadImage;
+
+  FilePath current_exe;
+  ASSERT_TRUE(PathService::Get(base::FILE_EXE, &current_exe));
+
+  int64 file_size_64 = 0;
+  ASSERT_TRUE(file_util::GetFileSize(current_exe, &file_size_64));
+  ASSERT_TRUE(file_size_64 < std::numeric_limits<std::size_t>::max());
+  size_t file_size = static_cast<size_t>(file_size_64);
+
+  // The module_path is valid while current_exe is unchanged and in scope.
+  const wchar_t* module_path = current_exe.value().c_str();
+  const size_t kStepSize = 2 * 1024 * 1024;
+
+  ASSERT_TRUE(PreReadImage(module_path, 0, kStepSize));
+  ASSERT_TRUE(PreReadImage(module_path, file_size / 4, kStepSize));
+  ASSERT_TRUE(PreReadImage(module_path, file_size / 2, kStepSize));
+  ASSERT_TRUE(PreReadImage(module_path, file_size, kStepSize));
+  ASSERT_TRUE(PreReadImage(module_path, file_size * 2, kStepSize));
+}
+
+TEST_F(FileUtilTest, PartialPreReadImage) {
+  using file_util::PartialPreReadImage;
+
+  FilePath current_exe;
+  ASSERT_TRUE(PathService::Get(base::FILE_EXE, &current_exe));
+
+  // The module_path is valid while current_exe is unchanged and in scope.

[Evan Martin, 2012/01/27 20:13:58]

Is this comment just pointing out that the wchar_t* remains valid for the body
of the function?  If so, I'd just omit it; we don't have such comments
elsewhere.

[Roger McFarlane (Google), 2012/01/27 21:25:54]

Done.

+  const wchar_t* module_path = current_exe.value().c_str();
+  const size_t kStepSize = 2 * 1024 * 1024;
+
+  ASSERT_TRUE(PartialPreReadImage(module_path, 0, kStepSize));
+  ASSERT_TRUE(PartialPreReadImage(module_path, 25, kStepSize));
+  ASSERT_TRUE(PartialPreReadImage(module_path, 50, kStepSize));
+  ASSERT_TRUE(PartialPreReadImage(module_path, 100, kStepSize));
+  ASSERT_TRUE(PartialPreReadImage(module_path, 150, kStepSize));
+}
+
+TEST_F(FileUtilTest, PartialPreReadImageOnDisk) {
+  using file_util::internal::PartialPreReadImageOnDisk;
+
+  FilePath current_exe;
+  ASSERT_TRUE(PathService::Get(base::FILE_EXE, &current_exe));
+
+  // The module_path is valid while current_exe is unchanged and in scope.
+  const wchar_t* module_path = current_exe.value().c_str();
+  const size_t kChunkSize = 2 * 1024 * 1024;
+
+  ASSERT_TRUE(PartialPreReadImageOnDisk(module_path, 0, kChunkSize));
+  ASSERT_TRUE(PartialPreReadImageOnDisk(module_path, 25, kChunkSize));
+  ASSERT_TRUE(PartialPreReadImageOnDisk(module_path, 50, kChunkSize));
+  ASSERT_TRUE(PartialPreReadImageOnDisk(module_path, 100, kChunkSize));
+  ASSERT_TRUE(PartialPreReadImageOnDisk(module_path, 150, kChunkSize));
+}
+
+TEST_F(FileUtilTest, PartialPreReadImageInMemory) {
+  using file_util::internal::PartialPreReadImageInMemory;
+
+  // The module_path is valid while current_exe is unchanged and in scope.
+  FilePath current_exe;
+  ASSERT_TRUE(PathService::Get(base::FILE_EXE, &current_exe));
+  const wchar_t* module_path = current_exe.value().c_str();
+
+  ASSERT_TRUE(PartialPreReadImageInMemory(module_path, 0));
+  ASSERT_TRUE(PartialPreReadImageInMemory(module_path, 25));
+  ASSERT_TRUE(PartialPreReadImageInMemory(module_path, 50));
+  ASSERT_TRUE(PartialPreReadImageInMemory(module_path, 100));
+  ASSERT_TRUE(PartialPreReadImageInMemory(module_path, 150));
+}
+
 #endif  // defined(OS_WIN)
 
 #if defined(OS_POSIX)
 
 TEST_F(FileUtilTest, CreateAndReadSymlinks) {
   FilePath link_from = temp_dir_.path().Append(FPL("from_file"));
   FilePath link_to = temp_dir_.path().Append(FPL("to_file"));
   CreateTextFile(link_to, bogus_content);
 
   ASSERT_TRUE(file_util::CreateSymbolicLink(link_to, link_from))
@@ skipping 1604 matching lines @@
       file_util::VerifyPathControlledByUser(
           base_dir_, text_file_, uid_, ok_gids_));
   EXPECT_TRUE(
       file_util::VerifyPathControlledByUser(
           sub_dir_, text_file_, uid_, ok_gids_));
 }
 
 #endif  // defined(OS_POSIX)
 
 }  // namespace