[windows] Make calls to exit(), _exit(), abort(), and ExitProcess() from the renderer process resul…

base/win/dllmain.cc

 // 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.
 
 // Windows doesn't support pthread_key_create's destr_function, and in fact
 // it's a bit tricky to get code to run when a thread exits.  This is
 // cargo-cult magic from http://www.codeproject.com/threads/tls.asp.
 // We are trying to be compatible with both a LoadLibrary style invocation, as
 // well as static linking. This code only needs to be included if we use
 // LoadLibrary, but it hooks into the "standard" set of TLS callbacks that are
 // provided for static linking.
 
 // This code is deliberately written to match the style of calls seen in
 // base/threading/thread_local_storage_win.cc.  Please keep the two in sync if
 // coding conventions are changed.
 
 // WARNING: Do *NOT* try to include this in the construction of the base
 // library, even though it potentially drives code in
 // base/threading/thread_local_storage_win.cc.  If you do, some users will end
 // up getting duplicate definition of DllMain() in some of their later links.
 
 // Force a reference to _tls_used to make the linker create the TLS directory
 // if it's not already there (that is, even if __declspec(thread) is not used).
 // Force a reference to p_thread_callback_dllmain_typical_entry to prevent whole
 // program optimization from discarding the variables.
 
 #include <windows.h>
 
-#include "base/logging.h"
+#include "base/compiler_specific.h"
 
 // Indicate if another service is scanning the callbacks.  When this becomes
 // set to true, then DllMain() will stop supporting the callback service. This
 // value is set to true the first time any of our callbacks are called, as that
 // shows that some other service is handling callbacks.
 static bool linker_notifications_are_active = false;
 
+// Indicates if we should crash in response to DLL_PROCESS_DETACH.
+static bool crash_on_process_detach = false;
+
 // This will be our mostly no-op callback that we'll list.  We won't
 // deliberately call it, and if it is called, that means we don't need to do any
 // of the callbacks anymore.  We expect such a call to arrive via a
 // THREAD_ATTACH message, long before we'd have to perform our THREAD_DETACH
 // callbacks.
 static void NTAPI on_callback(PVOID h, DWORD reason, PVOID reserved);
 
 #ifdef _WIN64
 
 #pragma comment(linker, "/INCLUDE:_tls_used")
@@ skipping 29 matching lines @@
 
 #pragma data_seg(push, old_seg)
 // Use a typical possible name in the .CRT$XL? list of segments.
 #pragma data_seg(".CRT$XLB")
 PIMAGE_TLS_CALLBACK p_thread_callback_dllmain_typical_entry = on_callback;
 #pragma data_seg(pop, old_seg)
 
 #endif  // _WIN64
 }  // extern "C"
 
+NOINLINE static void CrashOnProcessDetach() {
+  *((int*)0) = 0x356;
+}
 
 // Make DllMain call the listed callbacks.  This way any third parties that are
 // linked in will also be called.
 BOOL WINAPI DllMain(PVOID h, DWORD reason, PVOID reserved) {
+  if (DLL_PROCESS_DETACH == reason && crash_on_process_detach)
+    CrashOnProcessDetach();
+
   if (DLL_THREAD_DETACH != reason && DLL_PROCESS_DETACH != reason)
     return true;  // We won't service THREAD_ATTACH calls.
 
   if (linker_notifications_are_active)
     return true;  // Some other service is doing this work.
 
   for (PIMAGE_TLS_CALLBACK* it = &__xl_a; it < &__xl_z; ++it) {
     if (*it == NULL || *it == on_callback)
       continue;  // Don't bother to call our own callback.
     (*it)(h, reason, reserved);
   }
   return true;
 }
 
 static void NTAPI on_callback(PVOID h, DWORD reason, PVOID reserved) {
   // Do nothing.  We were just a place holder in the list used to test that we
   // call all items.
   // If we are called, it means that some other system is scanning the callbacks
   // and we don't need to do so in DllMain().
   linker_notifications_are_active = true;
   // Note: If some other routine some how plays this same game... we could both
   // decide not to do the scanning <sigh>, but this trick should suppress
   // duplicate calls on Vista, where the runtime takes care of the callbacks,
   // and allow us to do the callbacks on XP, where we are currently devoid of
   // callbacks (due to an explicit LoadLibrary call).
 }
+
+namespace base {
+namespace win {
+
+void DLLMain_SetCrashOnProcessDetach(bool crash) {

[rvargas (doing something else), 2012/03/21 03:13:45]

This is problematic because this file is not part of base.dll. It actually lives
in chrome land, so the namespace is kind of funky.

How about placing the static variable in its own file (living and exported from
base), and having this file just reading the value? That also means that the
breakpad code can freely call the method to reset the value.

[eroman, 2012/03/21 04:14:31]

Good point.

How about if I add exported methods to win_util.h, say:
  bool win::base::GetShouldCrashOnExit();
  void win::base::SetShouldCrashOnExit(bool);

dllmain.cc would then depend on GetShouldCrashOnExit().

[rvargas (doing something else), 2012/03/21 17:46:12]

Sounds good.

+  crash_on_process_detach = crash;
+}
+
+}  // namespace win
+}  // namespace base