Replace scoped_ptr with unique_ptr in webrtc/base/

webrtc/base/win32filesystem.cc

 /*
  *  Copyright 2004 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.
  */
 
 #include "webrtc/base/win32filesystem.h"
 
 #include "webrtc/base/win32.h"
 #include <shellapi.h>
 #include <shlobj.h>
 #include <tchar.h>
 
+#include <memory>
+
 #include "webrtc/base/arraysize.h"
 #include "webrtc/base/fileutils.h"
 #include "webrtc/base/pathutils.h"
-#include "webrtc/base/scoped_ptr.h"
 #include "webrtc/base/stream.h"
 #include "webrtc/base/stringutils.h"
 
 // In several places in this file, we test the integrity level of the process
 // before calling GetLongPathName. We do this because calling GetLongPathName
 // when running under protected mode IE (a low integrity process) can result in
 // a virtualized path being returned, which is wrong if you only plan to read.
 // TODO: Waiting to hear back from IE team on whether this is the
 // best approach; IEIsProtectedModeProcess is another possible solution.
 
@@ skipping 56 matching lines @@
   // Get the size of its TOKEN_USER structure. Return value is not checked
   // because we expect it to fail.
   DWORD token_user_size = 0;
   (void)::GetTokenInformation(process_token,
                               TokenUser,
                               NULL,
                               0,
                               &token_user_size);
 
   // Get the TOKEN_USER structure.
-  scoped_ptr<char[]> token_user_bytes(new char[token_user_size]);
+  std::unique_ptr<char[]> token_user_bytes(new char[token_user_size]);
   PTOKEN_USER token_user = reinterpret_cast<PTOKEN_USER>(
       token_user_bytes.get());
   memset(token_user, 0, token_user_size);
   BOOL success = ::GetTokenInformation(process_token,
                                        TokenUser,
                                        token_user,
                                        token_user_size,
                                        &token_user_size);
   // We're now done with this.
   ::CloseHandle(process_token);
   if (!success) {
     LOG_ERR(LS_ERROR) << "GetTokenInformation() failed";
     return false;
   }
 
   if (!IsValidSid(token_user->User.Sid)) {
     LOG_ERR(LS_ERROR) << "Current process has invalid user SID";
     return false;
   }
 
   // Compute size needed for an ACL that allows access to just this user.
   int acl_size = sizeof(ACL) + sizeof(ACCESS_ALLOWED_ACE) - sizeof(DWORD) +
       GetLengthSid(token_user->User.Sid);
 
   // Allocate it.
-  scoped_ptr<char[]> acl_bytes(new char[acl_size]);
+  std::unique_ptr<char[]> acl_bytes(new char[acl_size]);
   PACL acl = reinterpret_cast<PACL>(acl_bytes.get());
   memset(acl, 0, acl_size);
   if (!::InitializeAcl(acl, acl_size, ACL_REVISION)) {
     LOG_ERR(LS_ERROR) << "InitializeAcl() failed";
     return false;
   }
 
   // Allow access to only the current user.
   if (!::AddAccessAllowedAce(acl,
                              ACL_REVISION,
@@ skipping 283 matching lines @@
     return true;
   } else {
     LOG(LS_VERBOSE) << "GetDiskFreeSpaceEx returns error.";
     return false;
   }
 }
 
 Pathname Win32Filesystem::GetCurrentDirectory() {
   Pathname cwd;
   int path_len = 0;
-  scoped_ptr<wchar_t[]> path;
+  std::unique_ptr<wchar_t[]> path;
   do {
     int needed = ::GetCurrentDirectory(path_len, path.get());
     if (needed == 0) {
       // Error.
       LOG_GLE(LS_ERROR) << "::GetCurrentDirectory() failed";
       return cwd;  // returns empty pathname
     }
     if (needed <= path_len) {
       // It wrote successfully.
       break;
@@ skipping 14 matching lines @@
   temp_path16.append(1, '\0');
 
   SHFILEOPSTRUCT file_op = { 0 };
   file_op.wFunc = FO_DELETE;
   file_op.pFrom = temp_path16.c_str();
   file_op.fFlags = FOF_NOCONFIRMATION | FOF_NOERRORUI | FOF_SILENT;
   return (0 == SHFileOperation(&file_op));
 */
 
 }  // namespace rtc