Add a PartialPreReadImage function to file_util (on Windows).

chrome_frame/test/perf/chrome_frame_perftest.cc

 // Copyright (c) 2011 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 "chrome_frame/test/perf/chrome_frame_perftest.h"
 
 #include <atlwin.h>
 #include <atlhost.h>
 #include <map>
 #include <vector>
 #include <string>
 
 #include "base/debug/trace_event_win.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/path_service.h"
 #include "base/process_util.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "base/threading/platform_thread.h"
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
 #include "base/win/event_trace_consumer.h"
 #include "base/win/event_trace_controller.h"
 #include "base/win/registry.h"
 #include "base/win/scoped_bstr.h"
 #include "base/win/scoped_comptr.h"
 #include "base/win/scoped_variant.h"
+#include "chrome/app/image_pre_reader_win.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_paths_internal.h"
 #include "chrome/test/base/chrome_process_util.h"
 #include "chrome/test/perf/perf_test.h"
 #include "chrome/test/ui/ui_perf_test.h"
 #include "chrome_frame/chrome_tab.h"
 #include "chrome_frame/test_utils.h"
 #include "chrome_frame/utils.h"
 
@@ skipping 362 matching lines @@
     wnd.CreateControl(true);
     module.RunMessageLoop();
     *end_time = TimeTicks::Now();
   }
 };
 
 // This class measures the load time of chrome and chrome frame binaries
 class ChromeFrameBinariesLoadTest : public ChromeFrameStartupTestActiveX {
   static const size_t kStepSize = 4 * 1024;
  public:
+  enum PreReadType {
+    kPreReadNone,
+    kPreReadPartial,
+    kPreReadFull
+  };
+
   ChromeFrameBinariesLoadTest()
-      : pre_read_(false),
+      : pre_read_type_(kPreReadNone),
         step_size_(kStepSize),
-        bytes_to_read_(0) {}
+        bytes_to_read_(0),
+        percentage_to_preread_(25) {}
 
  protected:
   virtual void RunStartupTestImpl(TimeTicks* start_time,
                                   TimeTicks* end_time) {
     *start_time = TimeTicks::Now();
 
-    if (pre_read_) {
-      EXPECT_TRUE(file_util::PreReadImage(chrome_exe_.value().c_str(),
-                                          bytes_to_read_,
-                                          step_size_));
-      EXPECT_TRUE(file_util::PreReadImage(chrome_dll_.value().c_str(),
-                                          bytes_to_read_,
-                                          step_size_));
+    if (pre_read_type_ == kPreReadFull) {
+      EXPECT_TRUE(ImagePreReader::PreReadImage(chrome_exe_.value().c_str(),
+                                               bytes_to_read_,
+                                               step_size_));
+      EXPECT_TRUE(ImagePreReader::PreReadImage(chrome_dll_.value().c_str(),
+                                               bytes_to_read_,
+                                               step_size_));
+    } else if (pre_read_type_ == kPreReadPartial) {
+      EXPECT_TRUE(
+          ImagePreReader::PartialPreReadImage(chrome_exe_.value().c_str(),
+                                              percentage_to_preread_,
+                                              step_size_));
+      EXPECT_TRUE(
+          ImagePreReader::PartialPreReadImage(chrome_dll_.value().c_str(),
+                                              percentage_to_preread_,
+                                              step_size_));
     }
 
     HMODULE chrome_exe = LoadLibrary(chrome_exe_.value().c_str());
     EXPECT_TRUE(chrome_exe != NULL);
 
     HMODULE chrome_dll = LoadLibrary(chrome_dll_.value().c_str());
     EXPECT_TRUE(chrome_dll != NULL);
 
     *end_time = TimeTicks::Now();
 
     FreeLibrary(chrome_exe);
     FreeLibrary(chrome_dll);
   }
 
-  bool pre_read_;
+  PreReadType pre_read_type_;
   size_t bytes_to_read_;
   size_t step_size_;
+  uint8 percentage_to_preread_;
 };
 
 // This class provides functionality to run the startup performance test for
 // the ChromeFrame ActiveX against a reference build. At this point we only run
 // this test in warm mode.
 class ChromeFrameStartupTestActiveXReference
     : public ChromeFrameStartupTestActiveX {
  public:
   // override the browser directory to use the reference build instead.
   virtual void SetUp() {
@@ skipping 464 matching lines @@
 
     *start_time = TimeTicks::Now();
     HRESULT hr = host.CreateControl(L"AgControl.AgControl");
     EXPECT_HRESULT_SUCCEEDED(hr);
     *end_time = TimeTicks::Now();
 
     ReleaseHostComReferences(host);
   }
 };
 
+// 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(ImagePreReader, 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);
+
+  const wchar_t* module_path = current_exe.value().c_str();
+  const size_t kStepSize = 2 * 1024 * 1024;
+
+  ASSERT_TRUE(
+      ImagePreReader::PreReadImage(module_path, 0, kStepSize));
+  ASSERT_TRUE(
+      ImagePreReader::PreReadImage(module_path, file_size / 4, kStepSize));
+  ASSERT_TRUE(
+      ImagePreReader::PreReadImage(module_path, file_size / 2, kStepSize));
+  ASSERT_TRUE(
+      ImagePreReader::PreReadImage(module_path, file_size, kStepSize));
+  ASSERT_TRUE(
+      ImagePreReader::PreReadImage(module_path, file_size * 2, kStepSize));
+}
+
+TEST(ImagePreReader, PartialPreReadImage) {
+  FilePath current_exe;
+  ASSERT_TRUE(PathService::Get(base::FILE_EXE, &current_exe));
+
+  const wchar_t* module_path = current_exe.value().c_str();
+  const size_t kStepSize = 2 * 1024 * 1024;
+
+  ASSERT_TRUE(
+      ImagePreReader::PartialPreReadImage(module_path, 0, kStepSize));
+  ASSERT_TRUE(
+      ImagePreReader::PartialPreReadImage(module_path, 25, kStepSize));
+  ASSERT_TRUE(
+      ImagePreReader::PartialPreReadImage(module_path, 50, kStepSize));
+  ASSERT_TRUE(
+      ImagePreReader::PartialPreReadImage(module_path, 100, kStepSize));
+  ASSERT_TRUE(
+      ImagePreReader::PartialPreReadImage(module_path, 150, kStepSize));
+}
+
+TEST(ImagePreReader, PartialPreReadImageOnDisk) {
+  FilePath current_exe;
+  ASSERT_TRUE(PathService::Get(base::FILE_EXE, &current_exe));
+
+  const wchar_t* module_path = current_exe.value().c_str();
+  const size_t kChunkSize = 2 * 1024 * 1024;
+
+  ASSERT_TRUE(
+      ImagePreReader::PartialPreReadImageOnDisk(module_path, 0, kChunkSize));
+  ASSERT_TRUE(
+      ImagePreReader::PartialPreReadImageOnDisk(module_path, 25, kChunkSize));
+  ASSERT_TRUE(
+      ImagePreReader::PartialPreReadImageOnDisk(module_path, 50, kChunkSize));
+  ASSERT_TRUE(
+      ImagePreReader::PartialPreReadImageOnDisk(module_path, 100, kChunkSize));
+  ASSERT_TRUE(
+      ImagePreReader::PartialPreReadImageOnDisk(module_path, 150, kChunkSize));
+}
+
+TEST(ImagePreReader, PartialPreReadImageInMemory) {
+  FilePath current_exe;
+  ASSERT_TRUE(PathService::Get(base::FILE_EXE, &current_exe));
+  const wchar_t* module_path = current_exe.value().c_str();
+
+  ASSERT_TRUE(
+      ImagePreReader::PartialPreReadImageInMemory(module_path, 0));
+  ASSERT_TRUE(
+      ImagePreReader::PartialPreReadImageInMemory(module_path, 25));
+  ASSERT_TRUE(
+      ImagePreReader::PartialPreReadImageInMemory(module_path, 50));
+  ASSERT_TRUE(
+      ImagePreReader::PartialPreReadImageInMemory(module_path, 100));
+  ASSERT_TRUE(
+      ImagePreReader::PartialPreReadImageInMemory(module_path, 150));
+}
+
 TEST(ChromeFramePerf, DISABLED_HostActiveX) {
   // TODO(stoyan): Create a low integrity level thread && perform the test there
   SimpleModule module;
   AtlAxWinInit();
   CComObjectStackEx<ChromeFrameActiveXContainerPerf> wnd;
   wnd.CreateChromeFrameWindow("http://www.google.com");
   wnd.CreateControl(true);
   module.RunMessageLoop();
 }
 
@@ skipping 43 matching lines @@
 
 TEST_F(ChromeFrameBinariesLoadTest, PerfCold) {
   FilePath binaries_to_evict[] = {chrome_exe_, chrome_dll_};
   RunStartupTest("binary_load_cold", "t", "", true /* cold */,
                  arraysize(binaries_to_evict), binaries_to_evict,
                  false /* not important */, false);
 }
 
 TEST_F(ChromeFrameBinariesLoadTest, PerfColdPreRead) {
   FilePath binaries_to_evict[] = {chrome_exe_, chrome_dll_};
-  pre_read_ = true;
+  pre_read_type_ = kPreReadFull;
   RunStartupTest("binary_load_cold_preread", "t", "", true /* cold */,
                  arraysize(binaries_to_evict), binaries_to_evict,
                  false /* not important */, false);
 }
 
+TEST_F(ChromeFrameBinariesLoadTest, PerfColdPartialPreRead15) {
+  FilePath binaries_to_evict[] = {chrome_exe_, chrome_dll_};
+  pre_read_type_ = kPreReadPartial;
+  percentage_to_preread_ = 15;
+  RunStartupTest("binary_load_cold_partial_preread", "t", "", true /* cold */,
+                 arraysize(binaries_to_evict), binaries_to_evict,
+                 false /* not important */, false);
+}
+
+
+TEST_F(ChromeFrameBinariesLoadTest, PerfColdPartialPreRead25) {
+  FilePath binaries_to_evict[] = {chrome_exe_, chrome_dll_};
+  pre_read_type_ = kPreReadPartial;
+  percentage_to_preread_ = 25;
+  RunStartupTest("binary_load_cold_partial_preread", "t", "", true /* cold */,
+                 arraysize(binaries_to_evict), binaries_to_evict,
+                 false /* not important */, false);
+}
+
+TEST_F(ChromeFrameBinariesLoadTest, PerfColdPartialPreRead40) {
+  FilePath binaries_to_evict[] = {chrome_exe_, chrome_dll_};
+  pre_read_type_ = kPreReadPartial;
+  percentage_to_preread_ = 40;
+  RunStartupTest("binary_load_cold_partial_preread", "t", "", true /* cold */,
+                 arraysize(binaries_to_evict), binaries_to_evict,
+                 false /* not important */, false);
+}
+
 TEST_F(ChromeFrameStartupTestActiveXReference, PerfWarm) {
   RunStartupTest("warm", "t_ref", "about:blank", false /* cold */, 0, NULL,
                  true /* important */, false);
 }
 
 TEST_F(ChromeFrameStartupTestActiveX, PerfChromeFrameInitializationWarm) {
   RunStartupTest("ChromeFrame_init_warm", "t", "", false /* cold */, 0,
                  NULL, true /* important */, false);
 }
 
@@ skipping 460 matching lines @@
   PrintPerfTestResults(automation_provider_connect_monitor, kNumCycles,
                        "automationproviderconnect");
   PrintPerfTestResults(external_tab_navigate_monitor, kNumCycles,
                        "externaltabnavigate");
   PrintPerfTestResults(renderer_main_monitor, kNumCycles,
                        "beginrenderermain");
 #ifdef NDEBUG
   PrintPerfTestResults(pre_read_chrome_monitor, kNumCycles, "PreReadImage");
 #endif  // NDEBUG
 }