Convert scoped_ptr_malloc -> scoped_ptr, part 1.

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 17 matching lines @@
 // A handy symbolic constant.
 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 {
+struct VirtualFreeDeleter {
   void operator() (void* ptr) {
     ::VirtualFree(ptr, 0, MEM_RELEASE);
   }
 };
 
 // A wrapper for the Win32 ::SetFilePointer() function with some error checking.
 bool SetFilePointer(HANDLE file_handle, size_t position) {
   return position <= static_cast<size_t>(std::numeric_limits<LONG>::max()) &&
       ::SetFilePointer(file_handle,
                        static_cast<LONG>(position),
@@ skipping 196 matching lines @@
       &headers[nt_headers_start])->OptionalHeader.SizeOfHeaders;
   if (!ReadMissingBytes(file, &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_malloc<uint8, ScopedPtrVirtualFree> buffer(
-      reinterpret_cast<uint8*>(
+  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(
@@ skipping 144 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);
 }