Remove implicit HANDLE conversions from chrome.

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>
@@ skipping 209 matching lines @@
   if (!file.IsValid())
     return false;
 
   // Allocate a resizable buffer for the headers. We initially reserve as much
   // space as we typically see as the header size for chrome.dll and other
   // PE images.
   std::vector<uint8> headers;
   headers.reserve(kMinHeaderBufferSize);
 
   // Read, hopefully, all of the headers.
-  if (!ReadMissingBytes(file, &headers, kMinHeaderBufferSize))
+  if (!ReadMissingBytes(file.Get(), &headers, kMinHeaderBufferSize))
     return false;
 
   // The DOS header starts at offset 0 and allows us to get the offset of the
   // NT headers. Let's ensure we've read enough to capture the NT headers.
   size_t nt_headers_start =
       reinterpret_cast<IMAGE_DOS_HEADER*>(&headers[0])->e_lfanew;
   size_t nt_headers_end = nt_headers_start + sizeof(IMAGE_NT_HEADERS);
-  if (!ReadMissingBytes(file, &headers, nt_headers_end))
+  if (!ReadMissingBytes(file.Get(), &headers, nt_headers_end))
     return false;
 
   // Now that we've got the NT headers we can get the total header size,
   // including all of the section headers. Let's ensure we've read enough
   // to capture all of the header data.
   size_t size_of_headers = reinterpret_cast<IMAGE_NT_HEADERS*>(
       &headers[nt_headers_start])->OptionalHeader.SizeOfHeaders;
-  if (!ReadMissingBytes(file, &headers, size_of_headers))
+  if (!ReadMissingBytes(file.Get(), &headers, size_of_headers))
     return false;
 
   // Now we have all of the headers. This is enough to let us use the PEImage
   // wrapper to query the structure of the image.
   base::win::PEImage pe_image(reinterpret_cast<HMODULE>(&headers[0]));
   CHECK(pe_image.VerifyMagic());
 
   // Allocate a buffer to hold the pre-read bytes.
   scoped_ptr<uint8, VirtualFreeDeleter> buffer(
       static_cast<uint8*>(
           ::VirtualAlloc(NULL, max_chunk_size, MEM_COMMIT, PAGE_READWRITE)));
   if (buffer.get() == NULL)
     return false;
 
   // Iterate over each section, reading in a percentage of each.
   const IMAGE_SECTION_HEADER* section = NULL;
   for (UINT i = 0; (section = pe_image.GetSectionHeader(i)) != NULL; ++i) {
     CHECK_LE(reinterpret_cast<const uint8*>(section + 1),
              &headers[0] + headers.size());
-    if (!ReadThroughSection(
-            file, section, percentage, buffer.get(), max_chunk_size))
+    if (!ReadThroughSection(file.Get(), section, percentage, buffer.get(),
+                            max_chunk_size)) {
       return false;
+    }
   }
 
   // We're done.
   return true;
 }
 
 bool ImagePreReader::PartialPreReadImageInMemory(const wchar_t* file_path,
                                                  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
@@ skipping 71 matching lines @@
     LPVOID buffer = ::VirtualAlloc(NULL,
                                    actual_step_size,
                                    MEM_COMMIT,
                                    PAGE_READWRITE);
 
     if (buffer == NULL)
       return false;
 
     DWORD len;
     size_t total_read = 0;
-    while (::ReadFile(file, buffer, actual_step_size, &len, NULL) &&
+    while (::ReadFile(file.Get(), buffer, actual_step_size, &len, NULL) &&
            len > 0 &&
            (size_to_read ? total_read < size_to_read : true)) {
       total_read += static_cast<size_t>(len);
     }
     ::VirtualFree(buffer, 0, MEM_RELEASE);
   } else {
     // WinXP branch. Here, reading the DLL from disk doesn't do
     // what we want so instead we pull the pages into memory by loading
     // the DLL and touching pages at a stride. We use the system's page
     // size as the stride, ignoring the passed in step_size, to make sure
@@ skipping 40 matching lines @@
     // 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);
 }