Replace scoped_ptr with unique_ptr in webrtc/base/

webrtc/base/win32regkey.cc

 /*
  *  Copyright 2003 The WebRTC Project Authors. All rights reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
 // Registry configuration wrapers class implementation
 //
 // Change made by S. Ganesh - ganesh@google.com:
 //   Use SHQueryValueEx instead of RegQueryValueEx throughout.
 //   A call to the SHLWAPI function is essentially a call to the standard
 //   function but with post-processing:
 //   * to fix REG_SZ or REG_EXPAND_SZ data that is not properly null-terminated;
 //   * to expand REG_EXPAND_SZ data.
 
 #include "webrtc/base/win32regkey.h"
 
 #include <shlwapi.h>
 
+#include <memory>
+
 #include "webrtc/base/common.h"
 #include "webrtc/base/logging.h"
-#include "webrtc/base/scoped_ptr.h"
 
 namespace rtc {
 
 RegKey::RegKey() {
   h_key_ = NULL;
 }
 
 RegKey::~RegKey() {
   Close();
 }
@@ skipping 102 matching lines @@
 HRESULT RegKey::GetValue(const wchar_t* full_key_name,
                          const wchar_t* value_name,
                          float* value) {
   ASSERT(value != NULL);
   ASSERT(full_key_name != NULL);
 
   DWORD byte_count = 0;
   byte* buffer_raw = nullptr;
   HRESULT hr = GetValueStaticHelper(full_key_name, value_name,
                                     REG_BINARY, &buffer_raw, &byte_count);
-  scoped_ptr<byte[]> buffer(buffer_raw);
+  std::unique_ptr<byte[]> buffer(buffer_raw);
   if (SUCCEEDED(hr)) {
     ASSERT(byte_count == sizeof(*value));
     if (byte_count == sizeof(*value)) {
       *value = *reinterpret_cast<float*>(buffer.get());
     }
   }
   return hr;
 }
 
 HRESULT RegKey::GetValue(const wchar_t* full_key_name,
                          const wchar_t* value_name,
                          double* value) {
   ASSERT(value != NULL);
   ASSERT(full_key_name != NULL);
 
   DWORD byte_count = 0;
   byte* buffer_raw = nullptr;
   HRESULT hr = GetValueStaticHelper(full_key_name, value_name,
                                     REG_BINARY, &buffer_raw, &byte_count);
-  scoped_ptr<byte[]> buffer(buffer_raw);
+  std::unique_ptr<byte[]> buffer(buffer_raw);
   if (SUCCEEDED(hr)) {
     ASSERT(byte_count == sizeof(*value));
     if (byte_count == sizeof(*value)) {
       *value = *reinterpret_cast<double*>(buffer.get());
     }
   }
   return hr;
 }
 
 HRESULT RegKey::GetValue(const wchar_t* full_key_name,
                          const wchar_t* value_name,
                          wchar_t** value) {
   ASSERT(full_key_name != NULL);
   ASSERT(value != NULL);
 
   return GetValueStaticHelper(full_key_name, value_name, REG_SZ, value);
 }
 
 HRESULT RegKey::GetValue(const wchar_t* full_key_name,
                          const wchar_t* value_name,
                          std::wstring* value) {
   ASSERT(full_key_name != NULL);
   ASSERT(value != NULL);
 
   wchar_t* buffer_raw = nullptr;
   HRESULT hr = RegKey::GetValue(full_key_name, value_name, &buffer_raw);
-  scoped_ptr<wchar_t[]> buffer(buffer_raw);
+  std::unique_ptr<wchar_t[]> buffer(buffer_raw);
   if (SUCCEEDED(hr)) {
     value->assign(buffer.get());
   }
   return hr;
 }
 
 HRESULT RegKey::GetValue(const wchar_t* full_key_name,
                          const wchar_t* value_name,
                          std::vector<std::wstring>* value) {
   ASSERT(full_key_name != NULL);
@@ skipping 889 matching lines @@
     }
     CloseHandle(token);
   } else {
     LOG_GLE(LS_ERROR) << "OpenProcessToken(GetCurrentProcess) failed";
   }
 
   return ret;
 }
 
 }  // namespace rtc