Remove base/scoped_handle_win.h stub and fix up all callers to use the new location and namespace.

chrome_frame/test/chrome_frame_test_utils.cc

-// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+// Copyright (c) 2011 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 "chrome_frame/test/chrome_frame_test_utils.h"
 
 #include <atlbase.h>
 #include <atlwin.h>
 #include <iepmapi.h>
 #include <sddl.h>
 
 #include "app/clipboard/clipboard.h"
 #include "app/clipboard/scoped_clipboard_writer.h"
 #include "base/command_line.h"
 #include "base/file_path.h"
 #include "base/file_version_info.h"
 #include "base/path_service.h"
 #include "base/process_util.h"
-#include "base/scoped_handle.h"
 #include "base/scoped_ptr.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "base/utf_string_conversions.h"
 #include "base/win/registry.h"
+#include "base/win/scoped_handle.h"
 #include "base/win/windows_version.h"
 #include "ceee/ie/common/ceee_util.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_paths_internal.h"
 #include "chrome_frame/utils.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace chrome_frame_test {
 
@@ skipping 53 matching lines @@
 // windows on all threads of the process.
 // The return value is the number of visible windows a close request was
 // sent to.
 int CloseVisibleWindowsOnAllThreads(HANDLE process) {
   DWORD process_id = ::GetProcessId(process);
   if (process_id == 0) {
     NOTREACHED();
     return 0;
   }
 
-  ScopedHandle snapshot(CreateToolhelp32Snapshot(TH32CS_SNAPTHREAD, 0));
+  base::win::ScopedHandle snapshot(
+      CreateToolhelp32Snapshot(TH32CS_SNAPTHREAD, 0));
   if (!snapshot.IsValid()) {
     NOTREACHED();
     return 0;
   }
 
   int window_close_attempts = 0;
   THREADENTRY32 te = { sizeof(THREADENTRY32) };
   if (Thread32First(snapshot, &te)) {
     do {
       if (RTL_CONTAINS_FIELD(&te, te.dwSize, th32OwnerProcessID) &&
@@ skipping 193 matching lines @@
   DCHECK(!impersonated_);
   DCHECK(!IsImpersonated());
   HANDLE process_token_handle = NULL;
   BOOL ok = ::OpenProcessToken(GetCurrentProcess(), TOKEN_DUPLICATE,
                                &process_token_handle);
   if (!ok) {
     DLOG(ERROR) << "::OpenProcessToken failed: " << GetLastError();
     return ok;
   }
 
-  ScopedHandle process_token(process_token_handle);
+  base::win::ScopedHandle process_token(process_token_handle);
   // Create impersonation low integrity token.
   HANDLE impersonation_token_handle = NULL;
   ok = ::DuplicateTokenEx(process_token,
       TOKEN_QUERY | TOKEN_IMPERSONATE | TOKEN_ADJUST_DEFAULT, NULL,
       SecurityImpersonation, TokenImpersonation, &impersonation_token_handle);
   if (!ok) {
     DLOG(ERROR) << "::DuplicateTokenEx failed: " << GetLastError();
     return ok;
   }
 
   // TODO(stoyan): sandbox/src/restricted_token_utils.cc has
   // SetTokenIntegrityLevel function already.
-  ScopedHandle impersonation_token(impersonation_token_handle);
+  base::win::ScopedHandle impersonation_token(impersonation_token_handle);
   PSID integrity_sid = NULL;
   TOKEN_MANDATORY_LABEL tml = {0};
   ok = ::ConvertStringSidToSid(SDDL_ML_LOW, &integrity_sid);
   if (!ok) {
     DLOG(ERROR) << "::ConvertStringSidToSid failed: " << GetLastError();
     return ok;
   }
 
   tml.Label.Attributes = SE_GROUP_INTEGRITY | SE_GROUP_INTEGRITY_ENABLED;
   tml.Label.Sid = integrity_sid;
@@ skipping 197 matching lines @@
   DLOG_IF(ERROR, closed != 0) << "Closed " << closed << " windows forcefully";
 }
 
 // Attempt to connect to a running crash_service instance. Success occurs if we
 // can actually connect to the service's pipe or we receive ERROR_PIPE_BUSY.
 // Waits up to |timeout_ms| for success. |timeout_ms| may be 0, meaning only try
 // once, or negative, meaning wait forever.
 bool DetectRunningCrashService(int timeout_ms) {
   // Wait for the crash_service.exe to be ready for clients.
   base::Time start = base::Time::Now();
-  ScopedHandle new_pipe;
+  base::win::ScopedHandle new_pipe;
 
   while (true) {
     new_pipe.Set(::CreateFile(kCrashServicePipeName,
                               kCrashServicePipeDesiredAccess,
                               0,  // dwShareMode
                               NULL,  // lpSecurityAttributes
                               OPEN_EXISTING,
                               kCrashServicePipeFlagsAndAttributes,
                               NULL));  // hTemplateFile
 
@@ skipping 113 matching lines @@
                    bool wait) {
   bool result = true;
   base::NamedProcessIterator iter(executable_name, NULL);
   while (const base::ProcessEntry* entry = iter.NextProcessEntry()) {
     result &= base::KillProcessById(entry->pid(), exit_code, wait);
   }
   return result;
 }
 
 }  // namespace chrome_frame_test