Re-enable pre-read experiment as a finch field trial.

chrome/app/image_pre_reader_win.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 "chrome/app/image_pre_reader_win.h"
 
 #include <windows.h>
 #include <algorithm>
 #include <limits>
 #include <vector>
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/win/pe_image.h"
 #include "base/win/scoped_handle.h"
 #include "base/win/windows_version.h"
 
 namespace {
 
 // The minimum buffer size to allocate when reading the PE file headers.
 //
 // The PE file headers usually fit into a single 1KB page, and a PE file must
 // at least contain the initial page with the headers. That said, as long as
 // we expect at least sizeof(IMAGE_DOS_HEADER) bytes, we're ok.
 const size_t kMinHeaderBufferSize = 0x400;
 
 // A handy symbolic constant.
-const uint8 kOneHundredPercent = 100;
+const size_t kOneHundredPercent = 100;
 
 void StaticAssertions() {
   COMPILE_ASSERT(kMinHeaderBufferSize >= sizeof(IMAGE_DOS_HEADER),
                  min_header_buffer_size_at_least_as_big_as_the_dos_header);
 }
 
 // This struct provides a deallocation functor for use with scoped_ptr<T>
 // allocated with ::VirtualAlloc().
 struct ScopedPtrVirtualFree {
   void operator() (void* ptr) {
@@ skipping 58 matching lines @@
 //
 // Note that sections can have their tails implicitly initialized to zero
 // (i.e., their virtual size is larger than the raw size) and that raw data
 // is padded to the PE page size if the entire section is initialized (i.e.,
 // their raw data size will be larger than the virtual size).
 //
 // Any data after the initialized portion of the section will be soft-faulted
 // in (very quickly) as needed, so we don't need to include it in the returned
 // length.
 size_t GetPercentageOfSectionLength(const IMAGE_SECTION_HEADER* section,
-                                    uint8 percentage) {
+                                    size_t percentage) {
   DCHECK(section != NULL);
-  DCHECK_GT(percentage, 0);
+  DCHECK_GT(percentage, 0u);
   DCHECK_LE(percentage, kOneHundredPercent);
 
   size_t initialized_length = std::min(section->SizeOfRawData,
                                        section->Misc.VirtualSize);
 
   if (initialized_length == 0)
     return 0;
 
   size_t length = (initialized_length * percentage) / kOneHundredPercent;
 
   return std::max<size_t>(length, 1);
 }
 
 // Helper function to read through a |percentage| of the given |section|
 // of the file denoted by |file_handle|. The |temp_buffer| is (re)used as
 // a transient storage area as the section is read in chunks of
 // |temp_buffer_size| bytes.
 bool ReadThroughSection(HANDLE file_handle,
                         const IMAGE_SECTION_HEADER* section,
-                        uint8 percentage,
+                        size_t percentage,
                         void* temp_buffer,
                         size_t temp_buffer_size) {
   DCHECK(file_handle != INVALID_HANDLE_VALUE);
   DCHECK(section != NULL);
   DCHECK_LE(percentage, kOneHundredPercent);
   DCHECK(temp_buffer != NULL);
   DCHECK(temp_buffer_size > 0);
 
   size_t bytes_to_read = GetPercentageOfSectionLength(section, percentage);
   if (bytes_to_read == 0)
@@ skipping 41 matching lines @@
   while (touch_ptr < final_touch_ptr) {
     dummy = *touch_ptr;
     touch_ptr += system_info.dwPageSize;
   }
   dummy = *final_touch_ptr;
 }
 
 }  // namespace
 
 bool ImagePreReader::PartialPreReadImageOnDisk(const wchar_t* file_path,
-                                               uint8 percentage,
+                                               size_t percentage,
                                                size_t max_chunk_size) {
   // TODO(rogerm): change this to have the number of bytes pre-read per
   //     section be driven by a static table within the PE file (defaulting to
   //     full read if it's not there?) that's initialized by the optimization
   //     toolchain.
   DCHECK(file_path != NULL);
 
   if (percentage == 0)
     return true;
 
@@ skipping 63 matching lines @@
     if (!ReadThroughSection(
             file, section, percentage, buffer.get(), max_chunk_size))
       return false;
   }
 
   // We're done.
   return true;
 }
 
 bool ImagePreReader::PartialPreReadImageInMemory(const wchar_t* file_path,
-                                                 uint8 percentage) {
+                                                 size_t percentage) {
   // TODO(rogerm): change this to have the number of bytes pre-read per
   //     section be driven by a static table within the PE file (defaulting to
   //     full read if it's not there?) that's initialized by the optimization
   //     toolchain.
   DCHECK(file_path != NULL);
 
   if (percentage == 0)
     return true;
 
   if (percentage > kOneHundredPercent)
@@ skipping 102 matching lines @@
 
     // Page in then release the module.
     TouchPagesInRange(dll_module, dll_module_length);
     FreeLibrary(dll_module);
   }
 
   return true;
 }
 
 bool ImagePreReader::PartialPreReadImage(const wchar_t* file_path,
-                                         uint8 percentage,
+                                         size_t percentage,
                                          size_t max_chunk_size) {
   base::ThreadRestrictions::AssertIOAllowed();
 
   if (percentage >= kOneHundredPercent) {
     // If we're reading the whole image, we don't need to parse headers and
     // navigate sections, the basic PreReadImage() can be used to just step
     // blindly through the entire file / address-space.
     return PreReadImage(file_path, 0, max_chunk_size);
   }
 
   if (base::win::GetVersion() > base::win::VERSION_XP) {
     // Vista+ branch. On these OSes, we warm up the Image by reading its
     // file off the disk.
     return PartialPreReadImageOnDisk(file_path, percentage, max_chunk_size);
   }
 
   // WinXP branch. For XP, reading the image from disk doesn't do what we want
   // so instead we pull the pages into memory by loading the DLL and touching
   // initialized pages at a stride.
   return PartialPreReadImageInMemory(file_path, percentage);
 }