Revert of Sandbox: Make CreateRestrictedToken return a ScopedHandle.

sandbox/win/src/restricted_token.h

 // Copyright (c) 2010 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.
 
 #ifndef SANDBOX_SRC_RESTRICTED_TOKEN_H_
 #define SANDBOX_SRC_RESTRICTED_TOKEN_H_
 
 #include <windows.h>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/strings/string16.h"
-#include "base/win/scoped_handle.h"
 #include "sandbox/win/src/restricted_token_utils.h"
 #include "sandbox/win/src/security_level.h"
 #include "sandbox/win/src/sid.h"
 
 // Flags present in the Group SID list. These 2 flags are new in Windows Vista
 #ifndef SE_GROUP_INTEGRITY
 #define SE_GROUP_INTEGRITY (0x00000020L)
 #endif
 #ifndef SE_GROUP_INTEGRITY_ENABLED
 #define SE_GROUP_INTEGRITY_ENABLED (0x00000040L)
 #endif
 
 namespace sandbox {
 
 // Handles the creation of a restricted token using the effective token or
 // any token handle.
 // Sample usage:
 //    RestrictedToken restricted_token;
 //    unsigned err_code = restricted_token.Init(NULL);  // Use the current
 //                                                      // effective token
 //    if (ERROR_SUCCESS != err_code) {
 //      // handle error.
 //    }
 //
 //    restricted_token.AddRestrictingSid(ATL::Sids::Users().GetPSID());
-//    base::win::ScopedHandle token_handle;
-//    err_code = restricted_token.GetRestrictedToken(&token_handle);
+//    HANDLE token_handle;
+//    err_code = restricted_token.GetRestrictedTokenHandle(&token_handle);
 //    if (ERROR_SUCCESS != err_code) {
 //      // handle error.
 //    }
 //    [...]
+//    CloseHandle(token_handle);
 class RestrictedToken {
  public:
   // Init() has to be called before calling any other method in the class.
   RestrictedToken();
   ~RestrictedToken();
 
   // Initializes the RestrictedToken object with effective_token.
   // If effective_token is NULL, it initializes the RestrictedToken object with
   // the effective token of the current process.
   unsigned Init(HANDLE effective_token);
 
-  // Creates a restricted token.
+  // Creates a restricted token and returns its handle using the token_handle
+  // output parameter. This handle has to be closed by the caller.
   // If the function succeeds, the return value is ERROR_SUCCESS. If the
   // function fails, the return value is the win32 error code corresponding to
   // the error.
-  unsigned GetRestrictedToken(base::win::ScopedHandle* token) const;
+  unsigned GetRestrictedTokenHandle(HANDLE *token_handle) const;
 
   // Creates a restricted token and uses this new token to create a new token
-  // for impersonation. Returns this impersonation token.
+  // for impersonation. Returns the handle of this impersonation token using
+  // the token_handle output parameter. This handle has to be closed by
+  // the caller.
   //
   // If the function succeeds, the return value is ERROR_SUCCESS. If the
   // function fails, the return value is the win32 error code corresponding to
   // the error.
   //
-  // The sample usage is the same as the GetRestrictedToken function.
-  unsigned GetRestrictedTokenForImpersonation(
-      base::win::ScopedHandle* token) const;
+  // The sample usage is the same as the GetRestrictedTokenHandle function.
+  unsigned GetRestrictedTokenHandleForImpersonation(HANDLE *token_handle) const;
 
   // Lists all sids in the token and mark them as Deny Only except for those
   // present in the exceptions parameter. If there is no exception needed,
   // the caller can pass an empty list or NULL for the exceptions
   // parameter.
   //
   // If the function succeeds, the return value is ERROR_SUCCESS. If the
   // function fails, the return value is the win32 error code corresponding to
   // the error.
   //
@@ skipping 100 matching lines @@
   IntegrityLevel integrity_level_;
   // Tells if the object is initialized or not (if Init() has been called)
   bool init_;
 
   DISALLOW_COPY_AND_ASSIGN(RestrictedToken);
 };
 
 }  // namespace sandbox
 
 #endif  // SANDBOX_SRC_RESTRICTED_TOKEN_H_