Convert //content/browser from scoped_ptr to std::unique_ptr

content/browser/geolocation/wifi_data_provider_win.cc

 // Copyright (c) 2010 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.
 
 // Windows Vista uses the Native Wifi (WLAN) API for accessing WiFi cards. See
 // http://msdn.microsoft.com/en-us/library/ms705945(VS.85).aspx. Windows XP
 // Service Pack 3 (and Windows XP Service Pack 2, if upgraded with a hot fix)
 // also support a limited version of the WLAN API. See
 // http://msdn.microsoft.com/en-us/library/bb204766.aspx. The WLAN API uses
 // wlanapi.h, which is not part of the SDK used by Gears, so is replicated
@@ skipping 137 matching lines @@
                     AccessPointData* access_point_data);
 bool UndefineDosDevice(const base::string16& device_name);
 bool DefineDosDeviceIfNotExists(const base::string16& device_name);
 HANDLE GetFileHandle(const base::string16& device_name);
 // Makes the OID query and returns a Windows API error code.
 int PerformQuery(HANDLE adapter_handle,
                  BYTE* buffer,
                  DWORD buffer_size,
                  DWORD* bytes_out);
 bool ResizeBuffer(int requested_size,
-                  scoped_ptr<BYTE, base::FreeDeleter>* buffer);
+                  std::unique_ptr<BYTE, base::FreeDeleter>* buffer);
 // Gets the system directory and appends a trailing slash if not already
 // present.
 bool GetSystemDirectory(base::string16* path);
 }  // namespace
 
 WifiDataProvider* WifiDataProviderManager::DefaultFactoryFunction() {
   return new WifiDataProviderWin();
 }
 
 WifiDataProviderWin::WifiDataProviderWin() {
@@ skipping 295 matching lines @@
 
   RegCloseKey(network_cards_key);
   return true;
 }
 
 
 bool WindowsNdisApi::GetInterfaceDataNDIS(HANDLE adapter_handle,
                                           WifiData::AccessPointDataSet* data) {
   DCHECK(data);
 
-  scoped_ptr<BYTE, base::FreeDeleter> buffer(
+  std::unique_ptr<BYTE, base::FreeDeleter> buffer(
       static_cast<BYTE*>(malloc(oid_buffer_size_)));
   if (buffer == NULL) {
     return false;
   }
 
   DWORD bytes_out;
   int result;
 
   while (true) {
     bytes_out = 0;
@@ skipping 109 matching lines @@
                        buffer,
                        buffer_size,
                        bytes_out,
                        NULL)) {
     return GetLastError();
   }
   return ERROR_SUCCESS;
 }
 
 bool ResizeBuffer(int requested_size,
-                  scoped_ptr<BYTE, base::FreeDeleter>* buffer) {
+                  std::unique_ptr<BYTE, base::FreeDeleter>* buffer) {
   DCHECK_GT(requested_size, 0);
   DCHECK(buffer);
   if (requested_size > kMaximumBufferSize) {
     buffer->reset();
     return false;
   }
 
   buffer->reset(reinterpret_cast<BYTE*>(
       realloc(buffer->release(), requested_size)));
   return buffer != NULL;
 }
 
 bool GetSystemDirectory(base::string16* path) {
   DCHECK(path);
   // Return value includes terminating NULL.
   int buffer_size = ::GetSystemDirectory(NULL, 0);
   if (buffer_size == 0) {
     return false;
   }
-  scoped_ptr<base::char16[]> buffer(new base::char16[buffer_size]);
+  std::unique_ptr<base::char16[]> buffer(new base::char16[buffer_size]);
 
   // Return value excludes terminating NULL.
   int characters_written = ::GetSystemDirectory(buffer.get(), buffer_size);
   if (characters_written == 0) {
     return false;
   }
   DCHECK_EQ(buffer_size - 1, characters_written);
 
   path->assign(buffer.get(), characters_written);
 
   if (*path->rbegin() != L'\\') {
     path->append(L"\\");
   }
   DCHECK_EQ(L'\\', *path->rbegin());
   return true;
 }
 }  // namespace
 
 }  // namespace content