GTTF: Make debug symbol "resolution" work even after binaries are moved.

base/debug/stack_trace_win.cc

 // 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/path_service.h"
 #include "base/process_util.h"
+#include "base/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;
 
@@ skipping 95 matching lines @@
  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 {
+    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;
+
+    // Work around a mysterious hang on Windows XP.
+    if (base::win::GetVersion() < base::win::VERSION_VISTA)
+      return;
+
+    // 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.
+    wchar_t symbols_path[1024];
+
+    // Note: The below function takes buffer size as number of characters,
+    // not number of bytes!
+    if (!SymGetSearchPathW(GetCurrentProcess(),
+                           symbols_path,
+                           arraysize(symbols_path))) {
+      DLOG(WARNING) << "SymGetSearchPath failed: ";
+      return;
+    }
+
+    FilePath module_path;
+    if (!PathService::Get(FILE_EXE, &module_path)) {
+      DLOG(WARNING) << "PathService::Get(FILE_EXE) failed.";

[cpu_(ooo_6.6-7.5), 2013/04/10 23:19:26]

I would seem to me that we should avoid calling dlog , or any log here since
this function can be called inside a log statement.. is that so?

[Paweł Hajdan Jr., 2013/04/10 23:50:19]

There was a DLOG here already and I think it's useful to have some kind of
indication of failure here.

I've tried to produce a pathological situation of calling this on a line that
also has LOG, but it's fine. I think it's evaluated before calling expansion of
LOG, so I wouldn't expect any re-entrancy problems here.

+      return;
+    }
+
+    std::wstring new_path(std::wstring(symbols_path) +
+                          L";" + module_path.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
 
@@ skipping 74 matching lines @@
       (*os) << "\t" << trace_[i] << "\n";
     }
   } else {
     (*os) << "Backtrace:\n";
     context->OutputTraceToStream(trace_, count_, os);
   }
 }
 
 }  // namespace debug
 }  // namespace base