Deleted OS_WIN and all Windows specific files from base.

base/debug/stack_trace_win.cc

Index: base/debug/stack_trace_win.cc
diff --git a/base/debug/stack_trace_win.cc b/base/debug/stack_trace_win.cc
deleted file mode 100644
index 55d55624088d59a0ac82f09da611b4ee48627ede..0000000000000000000000000000000000000000
--- a/base/debug/stack_trace_win.cc
+++ /dev/null
@@ -1,283 +0,0 @@
-// 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 "base/debug/stack_trace.h"
-
-#include <windows.h>
-#include <dbghelp.h>
-
-#include <iostream>
-
-#include "base/basictypes.h"
-#include "base/logging.h"
-#include "base/memory/singleton.h"
-#include "base/process/launch.h"
-#include "base/strings/string_util.h"
-#include "base/synchronization/lock.h"
-#include "base/win/windows_version.h"
-
-namespace base {
-namespace debug {
-
-namespace {
-
-// 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) {
-  debug::StackTrace(info).Print();
-  if (g_previous_filter)
-    return g_previous_filter(info);
-  return EXCEPTION_CONTINUE_SEARCH;
-}
-
-FilePath GetExePath() {
-  wchar_t system_buffer[MAX_PATH];
-  GetModuleFileName(NULL, system_buffer, MAX_PATH);
-  system_buffer[MAX_PATH - 1] = L'\0';
-  return FilePath(system_buffer);
-}
-
-// SymbolContext is a threadsafe singleton that wraps the DbgHelp Sym* family
-// of functions.  The Sym* family of functions may only be invoked by one
-// thread at a time.  SymbolContext code may access a symbol server over the
-// network while holding the lock for this singleton.  In the case of high
-// latency, this code will adversely affect performance.
-//
-// There is also a known issue where this backtrace code can interact
-// badly with breakpad if breakpad is invoked in a separate thread while
-// we are using the Sym* functions.  This is because breakpad does now
-// share a lock with this function.  See this related bug:
-//
-//   http://code.google.com/p/google-breakpad/issues/detail?id=311
-//
-// This is a very unlikely edge case, and the current solution is to
-// just ignore it.
-class SymbolContext {
- public:
-  static SymbolContext* GetInstance() {
-    // We use a leaky singleton because code may call this during process
-    // termination.
-    return
-      Singleton<SymbolContext, LeakySingletonTraits<SymbolContext> >::get();
-  }
-
-  // Returns the error code of a failed initialization.
-  DWORD init_error() const {
-    return init_error_;
-  }
-
-  // For the given trace, attempts to resolve the symbols, and output a trace
-  // to the ostream os.  The format for each line of the backtrace is:
-  //
-  //    <tab>SymbolName[0xAddress+Offset] (FileName:LineNo)
-  //
-  // This function should only be called if Init() has been called.  We do not
-  // LOG(FATAL) here because this code is called might be triggered by a
-  // LOG(FATAL) itself. Also, it should not be calling complex code that is
-  // extensible like PathService since that can in turn fire CHECKs.
-  void OutputTraceToStream(const void* const* trace,
-                           size_t count,
-                           std::ostream* os) {
-    base::AutoLock lock(lock_);
-
-    for (size_t i = 0; (i < count) && os->good(); ++i) {
-      const int kMaxNameLength = 256;
-      DWORD_PTR frame = reinterpret_cast<DWORD_PTR>(trace[i]);
-
-      // Code adapted from MSDN example:
-      // http://msdn.microsoft.com/en-us/library/ms680578(VS.85).aspx
-      ULONG64 buffer[
-        (sizeof(SYMBOL_INFO) +
-          kMaxNameLength * sizeof(wchar_t) +
-          sizeof(ULONG64) - 1) /
-        sizeof(ULONG64)];
-      memset(buffer, 0, sizeof(buffer));
-
-      // Initialize symbol information retrieval structures.
-      DWORD64 sym_displacement = 0;
-      PSYMBOL_INFO symbol = reinterpret_cast<PSYMBOL_INFO>(&buffer[0]);
-      symbol->SizeOfStruct = sizeof(SYMBOL_INFO);
-      symbol->MaxNameLen = kMaxNameLength - 1;
-      BOOL has_symbol = SymFromAddr(GetCurrentProcess(), frame,
-                                    &sym_displacement, symbol);
-
-      // Attempt to retrieve line number information.
-      DWORD line_displacement = 0;
-      IMAGEHLP_LINE64 line = {};
-      line.SizeOfStruct = sizeof(IMAGEHLP_LINE64);
-      BOOL has_line = SymGetLineFromAddr64(GetCurrentProcess(), frame,
-                                           &line_displacement, &line);
-
-      // Output the backtrace line.
-      (*os) << "\t";
-      if (has_symbol) {
-        (*os) << symbol->Name << " [0x" << trace[i] << "+"
-              << sym_displacement << "]";
-      } else {
-        // If there is no symbol information, add a spacer.
-        (*os) << "(No symbol) [0x" << trace[i] << "]";
-      }
-      if (has_line) {
-        (*os) << " (" << line.FileName << ":" << line.LineNumber << ")";
-      }
-      (*os) << "\n";
-    }
-  }
-
- private:
-  friend struct DefaultSingletonTraits<SymbolContext>;
-
-  SymbolContext() : init_error_(ERROR_SUCCESS) {
-    // Initializes the symbols for the process.
-    // Defer symbol load until they're needed, use undecorated names, and
-    // get line numbers.
-    SymSetOptions(SYMOPT_DEFERRED_LOADS |
-                  SYMOPT_UNDNAME |
-                  SYMOPT_LOAD_LINES);
-    if (!SymInitialize(GetCurrentProcess(), NULL, TRUE)) {
-      init_error_ = GetLastError();
-      // TODO(awong): Handle error: SymInitialize can fail with
-      // ERROR_INVALID_PARAMETER.
-      // When it fails, we should not call debugbreak since it kills the current
-      // process (prevents future tests from running or kills the browser
-      // process).
-      DLOG(ERROR) << "SymInitialize failed: " << init_error_;
-      return;
-    }
-
-    init_error_ = ERROR_SUCCESS;
-
-    // When transferring the binaries e.g. between bots, path put
-    // into the executable will get off. To still retrieve symbols correctly,
-    // add the directory of the executable to symbol search path.
-    // All following errors are non-fatal.
-    const size_t kSymbolsArraySize = 1024;
-    scoped_ptr<wchar_t[]> symbols_path(new wchar_t[kSymbolsArraySize]);
-
-    // Note: The below function takes buffer size as number of characters,
-    // not number of bytes!
-    if (!SymGetSearchPathW(GetCurrentProcess(),
-                           symbols_path.get(),
-                           kSymbolsArraySize)) {
-      DLOG(WARNING) << "SymGetSearchPath failed: ";
-      return;
-    }
-
-    std::wstring new_path(std::wstring(symbols_path.get()) +
-                          L";" + GetExePath().DirName().value());
-    if (!SymSetSearchPathW(GetCurrentProcess(), new_path.c_str())) {
-      DLOG(WARNING) << "SymSetSearchPath failed.";
-      return;
-    }
-  }
-
-  DWORD init_error_;
-  base::Lock lock_;
-  DISALLOW_COPY_AND_ASSIGN(SymbolContext);
-};
-
-}  // namespace
-
-bool EnableInProcessStackDumping() {
-  // Add stack dumping support on exception on windows. Similar to OS_POSIX
-  // signal() handling in process_util_posix.cc.
-  g_previous_filter = SetUnhandledExceptionFilter(&StackDumpExceptionFilter);
-  RouteStdioToConsole();
-  return true;
-}
-
-// Disable optimizations for the StackTrace::StackTrace function. It is
-// important to disable at least frame pointer optimization ("y"), since
-// that breaks CaptureStackBackTrace() and prevents StackTrace from working
-// in Release builds (it may still be janky if other frames are using FPO,
-// but at least it will make it further).
-#if defined(COMPILER_MSVC)
-#pragma optimize("", off)
-#endif
-
-StackTrace::StackTrace() {
-  // When walking our own stack, use CaptureStackBackTrace().
-  count_ = CaptureStackBackTrace(0, arraysize(trace_), trace_, NULL);
-}
-
-#if defined(COMPILER_MSVC)
-#pragma optimize("", on)
-#endif
-
-StackTrace::StackTrace(const EXCEPTION_POINTERS* exception_pointers) {
-  // StackWalk64() may modify context record passed to it, so we will
-  // use a copy.
-  CONTEXT context_record = *exception_pointers->ContextRecord;
-  InitTrace(&context_record);
-}
-
-StackTrace::StackTrace(const CONTEXT* context) {
-  // StackWalk64() may modify context record passed to it, so we will
-  // use a copy.
-  CONTEXT context_record = *context;
-  InitTrace(&context_record);
-}
-
-void StackTrace::InitTrace(CONTEXT* context_record) {
-  // When walking an exception stack, we need to use StackWalk64().
-  count_ = 0;
-  // Initialize stack walking.
-  STACKFRAME64 stack_frame;
-  memset(&stack_frame, 0, sizeof(stack_frame));
-#if defined(_WIN64)
-  int machine_type = IMAGE_FILE_MACHINE_AMD64;
-  stack_frame.AddrPC.Offset = context_record->Rip;
-  stack_frame.AddrFrame.Offset = context_record->Rbp;
-  stack_frame.AddrStack.Offset = context_record->Rsp;
-#else
-  int machine_type = IMAGE_FILE_MACHINE_I386;
-  stack_frame.AddrPC.Offset = context_record->Eip;
-  stack_frame.AddrFrame.Offset = context_record->Ebp;
-  stack_frame.AddrStack.Offset = context_record->Esp;
-#endif
-  stack_frame.AddrPC.Mode = AddrModeFlat;
-  stack_frame.AddrFrame.Mode = AddrModeFlat;
-  stack_frame.AddrStack.Mode = AddrModeFlat;
-  while (StackWalk64(machine_type,
-                     GetCurrentProcess(),
-                     GetCurrentThread(),
-                     &stack_frame,
-                     context_record,
-                     NULL,
-                     &SymFunctionTableAccess64,
-                     &SymGetModuleBase64,
-                     NULL) &&
-         count_ < arraysize(trace_)) {
-    trace_[count_++] = reinterpret_cast<void*>(stack_frame.AddrPC.Offset);
-  }
-
-  for (size_t i = count_; i < arraysize(trace_); ++i)
-    trace_[i] = NULL;
-}
-
-void StackTrace::Print() const {
-  OutputToStream(&std::cerr);
-}
-
-void StackTrace::OutputToStream(std::ostream* os) const {
-  SymbolContext* context = SymbolContext::GetInstance();
-  DWORD error = context->init_error();
-  if (error != ERROR_SUCCESS) {
-    (*os) << "Error initializing symbols (" << error
-          << ").  Dumping unresolved backtrace:\n";
-    for (size_t i = 0; (i < count_) && os->good(); ++i) {
-      (*os) << "\t" << trace_[i] << "\n";
-    }
-  } else {
-    (*os) << "Backtrace:\n";
-    context->OutputTraceToStream(trace_, count_, os);
-  }
-}
-
-}  // namespace debug
-}  // namespace base