Move debug-related stuff from base to the base/debug directory and use the...

base/process_util_win.cc

 // 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.
 
 #include "base/process_util.h"
 
 #include <fcntl.h>
 #include <io.h>
 #include <windows.h>
 #include <userenv.h>
 #include <psapi.h>
 
 #include <ios>
 
 #include "base/command_line.h"
-#include "base/debug_util.h"
+#include "base/debug/stack_trace.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/scoped_ptr.h"
 #include "base/win/scoped_handle.h"
 #include "base/win/windows_version.h"
 
 // userenv.dll is required for CreateEnvironmentBlock().
 #pragma comment(lib, "userenv.lib")
 
 namespace base {
 
 namespace {
 
 // System pagesize. This value remains constant on x86/64 architectures.
 const int PAGESIZE_KB = 4;
 
 // HeapSetInformation function pointer.
 typedef BOOL (WINAPI* HeapSetFn)(HANDLE, HEAP_INFORMATION_CLASS, PVOID, SIZE_T);
 
 // Previous unhandled filter. Will be called if not NULL when we intercept an
 // exception. Only used in unit tests.
 LPTOP_LEVEL_EXCEPTION_FILTER g_previous_filter = NULL;
 
 // Prints the exception call stack.
 // This is the unit tests exception filter.
 long WINAPI StackDumpExceptionFilter(EXCEPTION_POINTERS* info) {
-  StackTrace(info).PrintBacktrace();
+  debug::StackTrace(info).PrintBacktrace();
   if (g_previous_filter)
     return g_previous_filter(info);
   return EXCEPTION_CONTINUE_SEARCH;
 }
 
 // Connects back to a console if available.
 void AttachToConsole() {
   if (!AttachConsole(ATTACH_PARENT_PROCESS)) {
     unsigned int result = GetLastError();
     // Was probably already attached.
@@ skipping 94 matching lines @@
 
   // We're screwed.
   NOTREACHED();
   return 0;
 }
 
 bool GetProcessIntegrityLevel(ProcessHandle process, IntegrityLevel *level) {
   if (!level)
     return false;
 
-  if (base::win::GetVersion() < base::win::VERSION_VISTA)
+  if (win::GetVersion() < base::win::VERSION_VISTA)
     return false;
 
   HANDLE process_token;
   if (!OpenProcessToken(process, TOKEN_QUERY | TOKEN_QUERY_SOURCE,
       &process_token))
     return false;
 
-  base::win::ScopedHandle scoped_process_token(process_token);
+  win::ScopedHandle scoped_process_token(process_token);
 
   DWORD token_info_length = 0;
   if (GetTokenInformation(process_token, TokenIntegrityLevel, NULL, 0,
                           &token_info_length) ||
       GetLastError() != ERROR_INSUFFICIENT_BUFFER)
     return false;
 
   scoped_array<char> token_label_bytes(new char[token_info_length]);
   if (!token_label_bytes.get())
     return false;
@@ skipping 142 matching lines @@
   sa_attr.bInheritHandle = TRUE;
   sa_attr.lpSecurityDescriptor = NULL;
 
   // Create the pipe for the child process's STDOUT.
   if (!CreatePipe(&out_read, &out_write, &sa_attr, 0)) {
     NOTREACHED() << "Failed to create pipe";
     return false;
   }
 
   // Ensure we don't leak the handles.
-  base::win::ScopedHandle scoped_out_read(out_read);
-  base::win::ScopedHandle scoped_out_write(out_write);
+  win::ScopedHandle scoped_out_read(out_read);
+  win::ScopedHandle scoped_out_write(out_write);
 
   // Ensure the read handle to the pipe for STDOUT is not inherited.
   if (!SetHandleInformation(out_read, HANDLE_FLAG_INHERIT, 0)) {
     NOTREACHED() << "Failed to disabled pipe inheritance";
     return false;
   }
 
   // Now create the child process
   PROCESS_INFORMATION proc_info = { 0 };
   STARTUPINFO start_info = { 0 };
@@ skipping 546 matching lines @@
 
   PERFORMANCE_INFORMATION info;
   if (!InternalGetPerformanceInfo(&info, sizeof(info))) {
     LOG(ERROR) << "Failed to fetch internal performance info.";
     return 0;
   }
   return (info.CommitTotal * system_info.dwPageSize) / 1024;
 }
 
 }  // namespace base