Fix StackTrace on Windows....

base/debug_util_win.cc

 // Copyright (c) 2006-2009 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_util.h"
 
 #include <windows.h>
 #include <dbghelp.h>
 
 #include <iostream>
@@ skipping 74 matching lines @@
 // just ignore it.
 class SymbolContext {
  public:
   static SymbolContext* Get() {
     // We use a leaky singleton because code may call this during process
     // termination.
     return
       Singleton<SymbolContext, LeakySingletonTraits<SymbolContext> >::get();
   }
 
-  // Initializes the symbols for the process if it hasn't been done yet.
-  // Subsequent calls will not reinitialize the symbol, but instead return
-  // the error code from the first call.
-  bool Init() {
-    AutoLock lock(lock_);
-    if (!initialized_) {
-      process_ = GetCurrentProcess();
-
-      // 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(process_, NULL, TRUE)) {
-        init_error_ = ERROR_SUCCESS;
-      } else {
-        init_error_ = GetLastError();
-      }
-    }
-
-    initialized_ = true;
-    return init_error_ == ERROR_SUCCESS;
-  }
-
-  // Returns the error code of a failed initialization.  This 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.  Instead,
-  // we log an ERROR, and return ERROR_INVALID_DATA.
-  DWORD init_error() {
-    if (!initialized_) {
-      LOG(ERROR) << "Calling GetInitError() before Init() was called.  "
-                 << "Returning ERROR_INVALID_DATA.";
-      return ERROR_INVALID_DATA;
-    }
-
+  // Returns the error code of a failed initialization.
+  DWORD init_error() const {
     return init_error_;
   }
 
-  // Returns the process this was initialized for.  This should only be
-  // called if Init() has been called.  We LOG(ERROR) in this situation.
-  // LOG(FATAL) is not used because this code is might be triggered
-  // by a LOG(FATAL) itself.
-  HANDLE process() {
-    if (!initialized_) {
-      LOG(ERROR) << "Calling process() before Init() was called. "
-                 << "Returning NULL.";
-      return NULL;
-    }
-
-    return process_;
-  }
-
   // 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.
   void OutputTraceToStream(const std::vector<void*>& trace, std::ostream* os) {
     AutoLock lock(lock_);
 
     for (size_t i = 0; (i < trace.size()) && 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)];
 
       // 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;
-      BOOL has_symbol = SymFromAddr(process(), frame,
+      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(process(), frame,
+      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 informtion, add a spacer.
         (*os) << "(No symbol) [0x" << trace[i] << "]";
       }
       if (has_line) {
         (*os) << " (" << line.FileName << ":" << line.LineNumber << ")";
       }
       (*os) << "\n";
     }
   }
 
-  SymbolContext()
-    : initialized_(false),
-      process_(NULL),
-      init_error_(ERROR_SUCCESS) {
+ 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_ = ERROR_SUCCESS;
+    } else {
+      __debugbreak();
+      init_error_ = GetLastError();
+    }
   }
 
- private:
+  DWORD init_error_;
   Lock lock_;
-  bool initialized_;
-  HANDLE process_;
-  DWORD init_error_;
-
   DISALLOW_COPY_AND_ASSIGN(SymbolContext);
 };
 
 }  // namespace
 
 // Note: Does not use the CRT.
 bool DebugUtil::SpawnDebuggerOnProcess(unsigned process_id) {
   wchar_t reg_value[1026];
   int len = arraysize(reg_value);
   if (RegReadString(HKEY_LOCAL_MACHINE,
@@ skipping 46 matching lines @@
     trace_.resize(0);
   }
 }
 
 void StackTrace::PrintBacktrace() {
   OutputToStream(&std::cerr);
 }
 
 void StackTrace::OutputToStream(std::ostream* os) {
   SymbolContext* context = SymbolContext::Get();
-
-  if (context->Init() != ERROR_SUCCESS) {
-    DWORD error = context->init_error();
+  DWORD error = context->init_error();
+  if (error != ERROR_SUCCESS) {
     (*os) << "Error initializing symbols (" << error
           << ").  Dumping unresolved backtrace:\n";
     for (size_t i = 0; (i < trace_.size()) && os->good(); ++i) {
       (*os) << "\t" << trace_[i] << "\n";
     }
   } else {
     (*os) << "Backtrace:\n";
     context->OutputTraceToStream(trace_, os);
   }
 }