Linux: Catch X errors and force a crash....

chrome/app/chrome_dll_main.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.
 
 // TODO(port): the ifdefs in here are a first step towards trying to determine
 // the correct abstraction for all the OS functionality required at this
 // stage of process initialization. It should not be taken as a final
 // abstraction.
 
 #include "build/build_config.h"
 
 #if defined(OS_WIN)
 #include <algorithm>
 #include <atlbase.h>
 #include <atlapp.h>
 #include <malloc.h>
 #include <new.h>
 #elif defined(OS_POSIX)
 #include <locale.h>
 #include <signal.h>
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <unistd.h>
 #endif
 
-#if defined(OS_POSIX) && !defined(OS_MACOSX)
+#if defined(USE_X11)
 #include <gdk/gdk.h>
 #include <glib.h>
 #include <gtk/gtk.h>
 #include <stdlib.h>
 #include <string.h>
 #endif
 
 #include "app/app_paths.h"
 #include "app/app_switches.h"
 #include "app/resource_bundle.h"
@@ skipping 20 matching lines @@
 #include "chrome/common/logging_chrome.h"
 #include "chrome/common/main_function_params.h"
 #include "chrome/common/sandbox_init_wrapper.h"
 #include "chrome/common/url_constants.h"
 #include "ipc/ipc_switches.h"
 
 #if defined(USE_NSS)
 #include "base/nss_util.h"
 #endif
 
+#if defined(USE_X11)
+#include "app/x11_util.h"
+#endif
+
 #if defined(OS_LINUX)
 #include "chrome/browser/renderer_host/render_sandbox_host_linux.h"
 #include "chrome/browser/zygote_host_linux.h"
 #endif
 
 #if defined(OS_MACOSX)
 #include "app/l10n_util_mac.h"
 #include "base/mac_util.h"
 #include "chrome/common/chrome_paths_internal.h"
 #include "chrome/app/breakpad_mac.h"
@@ skipping 118 matching lines @@
 // some apps fail to properly escape arguments.
 bool HasDeprecatedArguments(const std::wstring& command_line) {
   const wchar_t kChromeHtml[] = L"chromehtml:";
   std::wstring command_line_lower = command_line;
   // We are only searching for ASCII characters so this is OK.
   StringToLowerASCII(&command_line_lower);
   std::wstring::size_type pos = command_line_lower.find(kChromeHtml);
   return (pos != std::wstring::npos);
 }
 
-#endif  // OS_WIN
+#endif  // defined(OS_WIN)
 
-#if defined(OS_POSIX) && !defined(OS_MACOSX)
+#if defined(USE_X11)
 static void GLibLogHandler(const gchar* log_domain,
                            GLogLevelFlags log_level,
                            const gchar* message,
                            gpointer userdata) {
   if (!log_domain)
     log_domain = "<unknown>";
   if (!message)
     message = "<no message>";
 
   if (strstr(message, "Loading IM context type") ||
@@ skipping 34 matching lines @@
     g_log_set_handler(kLogDomains[i],
                       static_cast<GLogLevelFlags>(G_LOG_FLAG_RECURSION |
                                                   G_LOG_FLAG_FATAL |
                                                   G_LOG_LEVEL_ERROR |
                                                   G_LOG_LEVEL_CRITICAL |
                                                   G_LOG_LEVEL_WARNING),
                       GLibLogHandler,
                       NULL);
   }
 }
+#endif  // defined(USE_X11)
 
+#if defined(OS_LINUX)
 static void AdjustLinuxOOMScore(const std::string& process_type) {
   const int kMiscScore = 7;
   const int kPluginScore = 10;
   int score = -1;
 
   if (process_type == switches::kPluginProcess) {
     score = kPluginScore;
   } else if (process_type == switches::kUtilityProcess ||
              process_type == switches::kWorkerProcess ||
              process_type == switches::kGpuProcess ||
@@ skipping 13 matching lines @@
     LOG(WARNING) << "process type '" << process_type << "' "
                  << "should go through the zygote.";
     // When debugging, these process types can end up being run directly.
     return;
   } else {
     NOTREACHED() << "Unknown process type";
   }
   if (score > -1)
     base::AdjustOOMScore(base::GetCurrentProcId(), score);
 }
-#endif  // defined(OS_POSIX) && !defined(OS_MACOSX)
+#endif  // defined(OS_LINUX)
 
 // Register the invalid param handler and pure call handler to be able to
 // notify breakpad when it happens.
 void RegisterInvalidParamHandler() {
 #if defined(OS_WIN)
   _set_invalid_parameter_handler(InvalidParameter);
   _set_purecall_handler(PureCall);
   // Gather allocation failure.
   std::set_new_handler(&OnNoMemory);
   // Also enable the new handler for malloc() based failures.
@@ skipping 390 matching lines @@
     // sources.  The language should have been passed in to us from the
     // browser process as a command line flag.
     DCHECK(parsed_command_line.HasSwitch(switches::kLang) ||
            process_type == switches::kZygoteProcess);
     ResourceBundle::InitSharedInstance(std::wstring());
 
 #if defined(OS_MACOSX)
     // Update the process name (need resources to get the strings, so
     // only do this when ResourcesBundle has been initialized).
     SetMacProcessName(process_type);
-#endif // defined(OS_MACOSX)
-
+#endif  // defined(OS_MACOSX)
   }
 
   if (!process_type.empty())
     CommonSubprocessInit();
 
 #if defined(OS_MACOSX)
   // On OS X the renderer sandbox needs to be initialized later in the startup
   // sequence in RendererMainPlatformDelegate::PlatformInitialize().
   if (process_type != switches::kRendererProcess &&
       process_type != switches::kExtensionProcess) {
@@ skipping 110 matching lines @@
     g_thread_init(NULL);
     // Glib type system initialization. Needed at least for gconf,
     // used in net/proxy/proxy_config_service_linux.cc. Most likely
     // this is superfluous as gtk_init() ought to do this. It's
     // definitely harmless, so retained as a reminder of this
     // requirement for gconf.
     g_type_init();
     // gtk_init() can change |argc| and |argv|.
     gtk_init(&argc, &argv);
     SetUpGLibLogHandler();
+
+    x11_util::SetX11ErrorHandlers();
 #endif  // defined(OS_LINUX)
 
     rv = BrowserMain(main_params);
   } else {
     NOTREACHED() << "Unknown process type";
   }
 
   if (SubprocessNeedsResourceBundle(process_type))
     ResourceBundle::CleanupSharedInstance();
 
 #if defined(OS_WIN)
 #ifdef _CRTDBG_MAP_ALLOC
   _CrtDumpMemoryLeaks();
 #endif  // _CRTDBG_MAP_ALLOC
 
   _Module.Term();
 #endif
 
   logging::CleanupChromeLogging();
 
 #if defined(OS_MACOSX) && defined(GOOGLE_CHROME_BUILD)
   // TODO(mark): See the TODO(mark) above at InitCrashReporter.
   DestructCrashReporter();
 #endif  // OS_MACOSX && GOOGLE_CHROME_BUILD
 
   return rv;
 }