Cleanup/Remove Windows XP/Vista version checks from Windows sandbox code

sandbox/win/src/restricted_token_utils.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 <aclapi.h>
 #include <sddl.h>
 #include <vector>
 
 #include "sandbox/win/src/restricted_token_utils.h"
 
@@ skipping 60 matching lines @@
     case USER_LIMITED: {
       sid_exceptions.push_back(WinBuiltinUsersSid);
       sid_exceptions.push_back(WinWorldSid);
       sid_exceptions.push_back(WinInteractiveSid);
       privilege_exceptions.push_back(SE_CHANGE_NOTIFY_NAME);
       restricted_token.AddRestrictingSid(WinBuiltinUsersSid);
       restricted_token.AddRestrictingSid(WinWorldSid);
       restricted_token.AddRestrictingSid(WinRestrictedCodeSid);
 
       // This token has to be able to create objects in BNO.
-      // Unfortunately, on vista, it needs the current logon sid
+      // Unfortunately, on Vista+, it needs the current logon sid
       // in the token to achieve this. You should also set the process to be
       // low integrity level so it can't access object created by other
       // processes.
-      if (base::win::GetVersion() >= base::win::VERSION_VISTA)
-        restricted_token.AddRestrictingSidLogonSession();
+      restricted_token.AddRestrictingSidLogonSession();
       break;
     }
     case USER_RESTRICTED: {
       privilege_exceptions.push_back(SE_CHANGE_NOTIFY_NAME);
       restricted_token.AddUserSidForDenyOnly();
       restricted_token.AddRestrictingSid(WinRestrictedCodeSid);
       break;
     }
     case USER_LOCKDOWN: {
       restricted_token.AddUserSidForDenyOnly();
@@ skipping 94 matching lines @@
     case INTEGRITY_LEVEL_UNTRUSTED:
       return L"S-1-16-0";
     case INTEGRITY_LEVEL_LAST:
       return NULL;
   }
 
   NOTREACHED();
   return NULL;
 }
 DWORD SetTokenIntegrityLevel(HANDLE token, IntegrityLevel integrity_level) {
-  if (base::win::GetVersion() < base::win::VERSION_VISTA)
-    return ERROR_SUCCESS;
 
   const wchar_t* integrity_level_str = GetIntegrityLevelString(integrity_level);
   if (!integrity_level_str) {
     // No mandatory level specified, we don't change it.
     return ERROR_SUCCESS;
   }
 
   PSID integrity_sid = NULL;
   if (!::ConvertStringSidToSid(integrity_level_str, &integrity_sid))
     return ::GetLastError();
 
   TOKEN_MANDATORY_LABEL label = {};
   label.Label.Attributes = SE_GROUP_INTEGRITY;
   label.Label.Sid = integrity_sid;
 
   DWORD size = sizeof(TOKEN_MANDATORY_LABEL) + ::GetLengthSid(integrity_sid);
   BOOL result = ::SetTokenInformation(token, TokenIntegrityLevel, &label,
                                       size);
   auto last_error = ::GetLastError();
   ::LocalFree(integrity_sid);
 
   return result ? ERROR_SUCCESS : last_error;
 }
 
 DWORD SetProcessIntegrityLevel(IntegrityLevel integrity_level) {
-  if (base::win::GetVersion() < base::win::VERSION_VISTA)
-    return ERROR_SUCCESS;
 
   // We don't check for an invalid level here because we'll just let it
   // fail on the SetTokenIntegrityLevel call later on.
   if (integrity_level == INTEGRITY_LEVEL_LAST) {
     // No mandatory level specified, we don't change it.
     return ERROR_SUCCESS;
   }
 
   HANDLE token_handle;
   if (!::OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_DEFAULT,
                           &token_handle))
     return ::GetLastError();
 
   base::win::ScopedHandle token(token_handle);
 
   return SetTokenIntegrityLevel(token.Get(), integrity_level);
 }
 
 DWORD HardenTokenIntegrityLevelPolicy(HANDLE token) {
-  if (base::win::GetVersion() < base::win::VERSION_WIN7)
-    return ERROR_SUCCESS;
 
   DWORD last_error = 0;
   DWORD length_needed = 0;
 
   ::GetKernelObjectSecurity(token, LABEL_SECURITY_INFORMATION,
                             NULL, 0, &length_needed);
 
   last_error = ::GetLastError();
   if (last_error != ERROR_INSUFFICIENT_BUFFER)
     return last_error;
@@ skipping 27 matching lines @@
   }
 
   if (!::SetKernelObjectSecurity(token, LABEL_SECURITY_INFORMATION,
                                  security_desc))
     return ::GetLastError();
 
   return ERROR_SUCCESS;
 }
 
 DWORD HardenProcessIntegrityLevelPolicy() {
-  if (base::win::GetVersion() < base::win::VERSION_WIN7)
-    return ERROR_SUCCESS;
 
   HANDLE token_handle;
   if (!::OpenProcessToken(GetCurrentProcess(), READ_CONTROL | WRITE_OWNER,
                           &token_handle))
     return ::GetLastError();
 
   base::win::ScopedHandle token(token_handle);
 
   return HardenTokenIntegrityLevelPolicy(token.Get());
 }
 
 }  // namespace sandbox