Remove calls to rtc::scoped_ptr::accept

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.
  */
 
@@ skipping 125 matching lines @@
   return GetValueStaticHelper(full_key_name, value_name, REG_QWORD, value);
 }
 
 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;
-  scoped_ptr<byte[]> buffer;
+  byte* buffer_raw = nullptr;
   HRESULT hr = GetValueStaticHelper(full_key_name, value_name,
-                                    REG_BINARY, buffer.accept(), &byte_count);
+                                    REG_BINARY, &buffer_raw, &byte_count);
+  scoped_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;
-  scoped_ptr<byte[]> buffer;
+  byte* buffer_raw = nullptr;
   HRESULT hr = GetValueStaticHelper(full_key_name, value_name,
-                                    REG_BINARY, buffer.accept(), &byte_count);
+                                    REG_BINARY, &buffer_raw, &byte_count);
+  scoped_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);
 
-  scoped_ptr<wchar_t[]> buffer;
-  HRESULT hr = RegKey::GetValue(full_key_name, value_name, buffer.accept());
+  wchar_t* buffer_raw = nullptr;
+  HRESULT hr = RegKey::GetValue(full_key_name, value_name, &buffer_raw);
+  scoped_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