Convert scoped_ptr_malloc -> scoped_ptr, part 2.

net/proxy/dhcp_proxy_script_adapter_fetcher_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 "net/proxy/dhcp_proxy_script_adapter_fetcher_win.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop_proxy.h"
@@ skipping 215 matching lines @@
   wpad_params.OptionId = 252;
   wpad_params.IsVendor = FALSE;  // Surprising, but intentional.
 
   DHCPCAPI_PARAMS_ARRAY request_params = { 0 };
   request_params.nParams = 1;
   request_params.Params = &wpad_params;
 
   // The maximum message size is typically 4096 bytes on Windows per
   // http://support.microsoft.com/kb/321592
   DWORD result_buffer_size = 4096;
-  scoped_ptr_malloc<BYTE> result_buffer;
+  scoped_ptr<BYTE, base::FreeDeleter> result_buffer;
   int retry_count = 0;
   DWORD res = NO_ERROR;
   do {
-    result_buffer.reset(reinterpret_cast<BYTE*>(malloc(result_buffer_size)));
+    result_buffer.reset(static_cast<BYTE*>(malloc(result_buffer_size)));
 
     // Note that while the DHCPCAPI_REQUEST_SYNCHRONOUS flag seems to indicate
     // there might be an asynchronous mode, there seems to be (at least in
     // terms of well-documented use of this API) only a synchronous mode, with
     // an optional "async notifications later if the option changes" mode.
     // Even IE9, which we hope to emulate as IE is the most widely deployed
     // previous implementation of the DHCP aspect of WPAD and the only one
     // on Windows (Konqueror is the other, on Linux), uses this API with the
     // synchronous flag.  There seem to be several Microsoft Knowledge Base
     // articles about calls to this function failing when other flags are used
     // (e.g. http://support.microsoft.com/kb/885270) so we won't take any
     // chances on non-standard, poorly documented usage.
     res = ::DhcpRequestParams(DHCPCAPI_REQUEST_SYNCHRONOUS,
                               NULL,
                               const_cast<LPWSTR>(adapter_name_wide.c_str()),
                               NULL,
                               send_params, request_params,
                               result_buffer.get(), &result_buffer_size,
                               NULL);
     ++retry_count;
   } while (res == ERROR_MORE_DATA && retry_count <= 3);
 
   if (res != NO_ERROR) {
-    LOG(INFO) << "Error fetching PAC URL from DHCP: " << res;
+    LOG(WARNING) << "Error fetching PAC URL from DHCP: " << res;
     UMA_HISTOGRAM_COUNTS("Net.DhcpWpadUnhandledDhcpError", 1);
   } else if (wpad_params.nBytesData) {
     return SanitizeDhcpApiString(
         reinterpret_cast<const char*>(wpad_params.Data),
         wpad_params.nBytesData);
   }
 
   return "";
 }
 
@@ skipping 11 matching lines @@
   // first null in case of embedded NULLs; this is the outer
   // constructor that takes the result of c_str() on the inner.  If
   // the server is giving us back a buffer with embedded NULLs,
   // something is broken anyway.  Finally, trim trailing whitespace.
   std::string result(std::string(data, count_bytes).c_str());
   TrimWhitespaceASCII(result, TRIM_TRAILING, &result);
   return result;
 }
 
 }  // namespace net