Convert //sandbox to use std::unique_ptr

sandbox/win/src/restricted_token.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 "sandbox/win/src/restricted_token.h"
 
 #include <stddef.h>
 
+#include <memory>
 #include <vector>
 
 #include "base/logging.h"
-#include "base/memory/scoped_ptr.h"
 #include "sandbox/win/src/acl.h"
 #include "sandbox/win/src/win_utils.h"
 
 namespace {
 
 // Calls GetTokenInformation with the desired |info_class| and returns a buffer
 // with the result.
-scoped_ptr<BYTE[]> GetTokenInfo(const base::win::ScopedHandle& token,
-                                TOKEN_INFORMATION_CLASS info_class,
-                                DWORD* error) {
+std::unique_ptr<BYTE[]> GetTokenInfo(const base::win::ScopedHandle& token,
+                                     TOKEN_INFORMATION_CLASS info_class,
+                                     DWORD* error) {
   // Get the required buffer size.
   DWORD size = 0;
   ::GetTokenInformation(token.Get(), info_class, NULL, 0,  &size);
   if (!size) {
     *error = ::GetLastError();
     return nullptr;
   }
 
-  scoped_ptr<BYTE[]> buffer(new BYTE[size]);
+  std::unique_ptr<BYTE[]> buffer(new BYTE[size]);
   if (!::GetTokenInformation(token.Get(), info_class, buffer.get(), size,
                              &size)) {
     *error = ::GetLastError();
     return nullptr;
   }
 
   *error = ERROR_SUCCESS;
   return buffer;
 }
 
@@ skipping 178 matching lines @@
   token->Set(token_handle);
   return ERROR_SUCCESS;
 }
 
 DWORD RestrictedToken::AddAllSidsForDenyOnly(std::vector<Sid> *exceptions) {
   DCHECK(init_);
   if (!init_)
     return ERROR_NO_TOKEN;
 
   DWORD error;
-  scoped_ptr<BYTE[]> buffer =
+  std::unique_ptr<BYTE[]> buffer =
       GetTokenInfo(effective_token_, TokenGroups, &error);
 
   if (!buffer)
     return error;
 
   TOKEN_GROUPS* token_groups = reinterpret_cast<TOKEN_GROUPS*>(buffer.get());
 
   // Build the list of the deny only group SIDs
   for (unsigned int i = 0; i < token_groups->GroupCount ; ++i) {
     if ((token_groups->Groups[i].Attributes & SE_GROUP_INTEGRITY) == 0 &&
@@ skipping 26 matching lines @@
   sids_for_deny_only_.push_back(sid);
   return ERROR_SUCCESS;
 }
 
 DWORD RestrictedToken::AddUserSidForDenyOnly() {
   DCHECK(init_);
   if (!init_)
     return ERROR_NO_TOKEN;
 
   DWORD size = sizeof(TOKEN_USER) + SECURITY_MAX_SID_SIZE;
-  scoped_ptr<BYTE[]> buffer(new BYTE[size]);
+  std::unique_ptr<BYTE[]> buffer(new BYTE[size]);
   TOKEN_USER* token_user = reinterpret_cast<TOKEN_USER*>(buffer.get());
 
   BOOL result = ::GetTokenInformation(effective_token_.Get(), TokenUser,
                                       token_user, size, &size);
 
   if (!result)
     return ::GetLastError();
 
   Sid user = reinterpret_cast<SID*>(token_user->User.Sid);
   sids_for_deny_only_.push_back(user);
 
   return ERROR_SUCCESS;
 }
 
 DWORD RestrictedToken::DeleteAllPrivileges(
     const std::vector<base::string16> *exceptions) {
   DCHECK(init_);
   if (!init_)
     return ERROR_NO_TOKEN;
 
   DWORD error;
-  scoped_ptr<BYTE[]> buffer =
+  std::unique_ptr<BYTE[]> buffer =
       GetTokenInfo(effective_token_, TokenPrivileges, &error);
 
   if (!buffer)
     return error;
 
   TOKEN_PRIVILEGES* token_privileges =
       reinterpret_cast<TOKEN_PRIVILEGES*>(buffer.get());
 
   // Build the list of privileges to disable
   for (unsigned int i = 0; i < token_privileges->PrivilegeCount; ++i) {
@@ skipping 39 matching lines @@
   sids_to_restrict_.push_back(sid);  // No attributes
   return ERROR_SUCCESS;
 }
 
 DWORD RestrictedToken::AddRestrictingSidLogonSession() {
   DCHECK(init_);
   if (!init_)
     return ERROR_NO_TOKEN;
 
   DWORD error;
-  scoped_ptr<BYTE[]> buffer =
+  std::unique_ptr<BYTE[]> buffer =
       GetTokenInfo(effective_token_, TokenGroups, &error);
 
   if (!buffer)
     return error;
 
   TOKEN_GROUPS* token_groups = reinterpret_cast<TOKEN_GROUPS*>(buffer.get());
 
   SID *logon_sid = NULL;
   for (unsigned int i = 0; i < token_groups->GroupCount ; ++i) {
     if ((token_groups->Groups[i].Attributes & SE_GROUP_LOGON_ID) != 0) {
         logon_sid = static_cast<SID*>(token_groups->Groups[i].Sid);
         break;
     }
   }
 
   if (logon_sid)
     sids_to_restrict_.push_back(logon_sid);
 
   return ERROR_SUCCESS;
 }
 
 DWORD RestrictedToken::AddRestrictingSidCurrentUser() {
   DCHECK(init_);
   if (!init_)
     return ERROR_NO_TOKEN;
 
   DWORD size = sizeof(TOKEN_USER) + SECURITY_MAX_SID_SIZE;
-  scoped_ptr<BYTE[]> buffer(new BYTE[size]);
+  std::unique_ptr<BYTE[]> buffer(new BYTE[size]);
   TOKEN_USER* token_user = reinterpret_cast<TOKEN_USER*>(buffer.get());
 
   BOOL result = ::GetTokenInformation(effective_token_.Get(), TokenUser,
                                       token_user, size, &size);
 
   if (!result)
     return ::GetLastError();
 
   Sid user = reinterpret_cast<SID*>(token_user->User.Sid);
   sids_to_restrict_.push_back(user);
 
   return ERROR_SUCCESS;
 }
 
 DWORD RestrictedToken::AddRestrictingSidAllSids() {
   DCHECK(init_);
   if (!init_)
     return ERROR_NO_TOKEN;
 
   // Add the current user to the list.
   DWORD error = AddRestrictingSidCurrentUser();
   if (ERROR_SUCCESS != error)
     return error;
 
-  scoped_ptr<BYTE[]> buffer =
+  std::unique_ptr<BYTE[]> buffer =
       GetTokenInfo(effective_token_, TokenGroups, &error);
 
   if (!buffer)
     return error;
 
   TOKEN_GROUPS* token_groups = reinterpret_cast<TOKEN_GROUPS*>(buffer.get());
 
   // Build the list of restricting sids from all groups.
   for (unsigned int i = 0; i < token_groups->GroupCount ; ++i) {
     if ((token_groups->Groups[i].Attributes & SE_GROUP_INTEGRITY) == 0)
       AddRestrictingSid(reinterpret_cast<SID*>(token_groups->Groups[i].Sid));
   }
 
   return ERROR_SUCCESS;
 }
 
 DWORD RestrictedToken::SetIntegrityLevel(IntegrityLevel integrity_level) {
   integrity_level_ = integrity_level;
   return ERROR_SUCCESS;
 }
 
 void RestrictedToken::SetLockdownDefaultDacl() {
   lockdown_default_dacl_ = true;
 }
 
 }  // namespace sandbox