Revert 123149 (trying to find the cause of http://crbug.com/115479)

chrome/app/breakpad_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 "chrome/app/breakpad_win.h"
 
 #include <windows.h>
 #include <shellapi.h>
 #include <tchar.h>
 
@@ skipping 308 matching lines @@
         google_breakpad::CustomInfoEntry(L"num-views", L"N/A"));
   }
 
   static google_breakpad::CustomClientInfo custom_client_info;
   custom_client_info.entries = &g_custom_entries->front();
   custom_client_info.count = g_custom_entries->size();
 
   return &custom_client_info;
 }
 
-// Contains the information needed by InitCrashReporterMain().
+// Contains the information needed by the worker thread.
 struct CrashReporterInfo {
   google_breakpad::CustomClientInfo* custom_info;
   std::wstring exe_path;
   std::wstring process_type;
 };
 
 // This callback is used when we want to get a dump without crashing the
 // process.
 bool DumpDoneCallbackWhenNoCrash(const wchar_t*, const wchar_t*, void*,
                                  EXCEPTION_POINTERS* ex_info,
@@ skipping 258 matching lines @@
   base::win::RegKey hkcu_policy_key(HKEY_CURRENT_USER,
                                     policy::kRegistryMandatorySubKey, KEY_READ);
   if (hkcu_policy_key.ReadValueDW(key_name.c_str(), &value) == ERROR_SUCCESS) {
     *result = value != 0;
     return true;
   }
 
   return false;
 }
 
-// TODO(mseaborn): This function could be merged with InitCrashReporter().
-static void InitCrashReporterMain(CrashReporterInfo* param) {
-  scoped_ptr<CrashReporterInfo> info(param);
+static DWORD __stdcall InitCrashReporterThread(void* param) {
+  scoped_ptr<CrashReporterInfo> info(
+      reinterpret_cast<CrashReporterInfo*>(param));
 
   bool is_per_user_install =
       InstallUtil::IsPerUserInstall(info->exe_path.c_str());
 
   std::wstring channel_string;
   GoogleUpdateSettings::GetChromeChannelAndModifiers(!is_per_user_install,
                                                      &channel_string);
 
+  // GetCustomInfo can take a few milliseconds to get the file information, so
+  // we do it here so it can run in a separate thread.
   info->custom_info = GetCustomInfo(info->exe_path, info->process_type,
                                     channel_string);
 
   google_breakpad::ExceptionHandler::MinidumpCallback callback = NULL;
   LPTOP_LEVEL_EXCEPTION_FILTER default_filter = NULL;
   // We install the post-dump callback only for the browser and service
   // processes. It spawns a new browser/service process.
   if (info->process_type == L"browser") {
     callback = &DumpDoneCallback;
     default_filter = &ChromeExceptionFilter;
@@ skipping 31 matching lines @@
     // via policy).
     if (!controlled_by_policy)
       crash_reporting_enabled = GoogleUpdateSettings::GetCollectStatsConsent();
 
     if (!crash_reporting_enabled) {
       // Configuration managed or the user did not allow Google Update to send
       // crashes, we need to use our default crash handler instead, but only
       // for the browser/service processes.
       if (default_filter)
         InitDefaultCrashCallback(default_filter);
-      return;
+      return 0;
     }
 
     // Build the pipe name. It can be either:
     // System-wide install: "NamedPipe\GoogleCrashServices\S-1-5-18"
     // Per-user install: "NamedPipe\GoogleCrashServices\<user SID>"
     std::wstring user_sid;
     if (is_per_user_install) {
       if (!base::win::GetUserSidString(&user_sid)) {
         if (default_filter)
           InitDefaultCrashCallback(default_filter);
-        return;
+        return -1;
       }
     } else {
       user_sid = kSystemPrincipalSid;
     }
 
     pipe_name = kGoogleUpdatePipeName;
     pipe_name += user_sid;
   }
 #ifdef _WIN64
   // The protocol for connecting to the out-of-process Breakpad crash
@@ skipping 37 matching lines @@
       // handlers.
       google_breakpad::ExceptionHandler::HANDLER_NONE,
       dump_type, pipe_name.c_str(), info->custom_info);
 
   if (g_breakpad->IsOutOfProcess()) {
     // Tells breakpad to handle breakpoint and single step exceptions.
     // This might break JIT debuggers, but at least it will always
     // generate a crashdump for these exceptions.
     g_breakpad->set_handle_debug_exceptions(true);
   }
+
+  return 0;
 }
 
 void InitDefaultCrashCallback(LPTOP_LEVEL_EXCEPTION_FILTER filter) {
   previous_filter = SetUnhandledExceptionFilter(filter);
 }
 
 void InitCrashReporter() {
   const CommandLine& command = *CommandLine::ForCurrentProcess();
   if (!command.HasSwitch(switches::kDisableBreakpad)) {
     // Disable the message box for assertions.
     _CrtSetReportMode(_CRT_ASSERT, 0);
 
+    // Query the custom_info now because if we do it in the thread it's going to
+    // fail in the sandbox. The thread will delete this object.
     CrashReporterInfo* info(new CrashReporterInfo);
     info->process_type = command.GetSwitchValueNative(switches::kProcessType);
     if (info->process_type.empty())
       info->process_type = L"browser";
 
     wchar_t exe_path[MAX_PATH];
     exe_path[0] = 0;
     GetModuleFileNameW(NULL, exe_path, MAX_PATH);
     info->exe_path = exe_path;
 
-    InitCrashReporterMain(info);
+    // If this is not the browser, we can't be sure that we will be able to
+    // initialize the crash_handler in another thread, so we run it right away.
+    // This is important to keep the thread for the browser process because
+    // it may take some times to initialize the crash_service process.  We use
+    // the Windows worker pool to make better reuse of the thread.
+    if (info->process_type != L"browser") {
+      InitCrashReporterThread(info);
+    } else {
+      if (QueueUserWorkItem(
+              &InitCrashReporterThread,
+              info,
+              WT_EXECUTELONGFUNCTION) == 0) {
+        // We failed to queue to the worker pool, initialize in this thread.
+        InitCrashReporterThread(info);
+      }
+    }
   }
 }