bug 791775 - Update to Breakpad SVN r1047. r=glandium

--HG--
rename : toolkit/crashreporter/google-breakpad/src/third_party/linux/include/glog/log_severity.h => toolkit/crashreporter/google-breakpad/src/third_party/glog/src/glog/log_severity.h

toolkit/crashreporter/Makefile.in

@@ -68,6 +68,9 @@ ifeq ($(OS_TARGET),Android)
 DIRS += fileid
 # NDK5 workarounds
 DEFINES += -D_STLP_CONST_CONSTRUCTOR_BUG -D_STLP_NO_MEMBER_TEMPLATES
+TARGET_LOCAL_INCLUDES = \
+  -I$(topsrcdir)/toolkit/crashreporter/google-breakpad/src/common/android/include/ \
+  $(NULL)
 endif
 
 DIRS += client
@@ -76,7 +79,7 @@ ifdef MOZ_CRASHREPORTER_INJECTOR
 DIRS += injector
 endif
 
-LOCAL_INCLUDES = -I$(srcdir)/google-breakpad/src
+LOCAL_INCLUDES += -I$(srcdir)/google-breakpad/src
 DEFINES += -DUNICODE -D_UNICODE
 
 EXPORTS = \

toolkit/crashreporter/client/crashreporter_gtk_common.cpp

@@ -184,6 +184,7 @@ void LoadProxyinfo()
 gpointer SendThread(gpointer args)
 {
   string response, error;
+  long response_code;
 
   bool success = google_breakpad::HTTPUpload::SendRequest
     (gSendURL,
@@ -193,6 +194,7 @@ gpointer SendThread(gpointer args)
      gHttpProxy, gAuth,
      gCACertificateFile,
      &response,
+     &response_code,
      &error);
   if (success) {
     LogMessage("Crash report submitted successfully");

toolkit/crashreporter/google-breakpad/.hg_archival.txt

@@ -1,5 +0,0 @@
-repo: aa80aeafa44f5c17c84e1dac5a7119a6d1ef4341
-node: 2645d42a92c4144ec095d774a32d2fcaec1afa0b
-branch: default
-latesttag: null
-latesttagdistance: 581

toolkit/crashreporter/google-breakpad/.hgsvnexternals

@@ -1,7 +0,0 @@
-[.]
- src/testing -r175 http://googlemock.googlecode.com/svn/trunk/
- src/tools/gyp -r762 http://gyp.googlecode.com/svn/trunk
-[src/third_party/glog]
- glog http://google-glog.googlecode.com/svn/trunk
-[src/third_party/protobuf]
- protobuf http://protobuf.googlecode.com/svn/trunk

toolkit/crashreporter/google-breakpad/README.ANDROID

@@ -0,0 +1,139 @@
+Google Breakpad for Android
+===========================
+
+This document explains how to use the Google Breakpad client library
+on Android, and later generate valid stack traces from the minidumps
+it generates.
+
+This release supports ARM and x86 based Android systems. MIPS is not
+currently supported by Breakpad.
+
+I. Building the client library:
+===============================
+
+The Android client is built as a static library that you can
+link into your own Android native code. There are two ways to
+build it:
+
+I.1. Building with ndk-build:
+-----------------------------
+
+If you're using the ndk-build build system, you can follow
+these simple steps:
+
+  1/ Include android/google_breakpad/Android.mk from your own
+     project's Android.mk
+
+     This can be done either directly, or using ndk-build's
+     import-module feature.
+
+  2/ Link the library to one of your modules by using:
+
+     LOCAL_STATIC_LIBRARIES += breakpad_client
+
+NOTE: The client library requires a C++ STL implementation,
+      which you can select with APP_STL in your Application.mk
+
+      It has been tested succesfully with both STLport and GNU libstdc++
+
+
+II.1. Building with a standalone Android toolchain:
+---------------------------------------------------
+
+All you need to do is configure your build with the right 'host'
+value, and disable the processor and tools, as in:
+
+  $GOOGLE_BREAKPAD_PATH/configure --host=arm-linux-androideabi \
+                                  --disable-processor \
+                                  --disable-tools
+  make -j4
+
+The library will be under src/client/linux/libbreakpad_client.a
+
+You can also use 'make check' to run the test suite on a connected
+Android device. This requires the Android 'adb' tool to be in your
+path.
+
+II. Using the client library in Android:
+========================================
+
+The usage instructions are very similar to the Linux ones that are
+found at http://code.google.com/p/google-breakpad/wiki/LinuxStarterGuide
+
+1/ You need to include "client/linux/handler/exception_handler.h" from a C++
+   source file.
+
+2/ If you're not using ndk-build, you also need to:
+
+   - add the following to your compiler include search paths:
+       $GOOGLE_BREAKPAD_PATH/src
+       $GOOGLE_BREAKPAD_PATH/src/common/android/include
+
+   - add -llog to your linker flags
+
+   Note that ndk-build does that for your automatically.
+
+3/ Keep in mind that there is no /tmp directory on Android.
+
+   If you use the library from a regular Android applications, specify a
+   path under your app-specific storage directory. An alternative is to
+   store them on the SDCard, but this requires a specific permission.
+
+For a concrete example, see the sample test application under
+android/sample_app. See its README for more information.
+
+
+III. Getting a stack trace on the host:
+=======================================
+
+This process is similar to other platforms, but here's a quick example:
+
+1/ Retrieve the minidumps on your development machine.
+
+2/ Dump the symbols for your native libraries with the 'dump_syms' tool.
+   This first requires building the host version of Google Breakpad, then
+   calling:
+
+      dump_syms $PROJECT_PATH/obj/local/$ABI/libfoo.so > libfoo.so.sym
+
+3/ Create the symbol directory hierarchy.
+
+   The first line of the generated libfoo.so.sym will have a "MODULE"
+   entry that carries a hexadecimal version number, e.g.:
+
+     MODULE Linux arm D51B4A5504974FA6ECC1869CAEE3603B0 test_google_breakpad
+
+   Note: The second field could be either 'Linux' or 'Android'.
+
+   Extract the version number, and a 'symbol' directory, for example:
+
+      $PROJECT_PATH/symbols/libfoo.so/$VERSION/
+
+   Copy/Move your libfoo.sym file there.
+
+4/ Invoke minidump_stackwalk to create the stack trace:
+
+     minidump_stackwalk $MINIDUMP_FILE $PROJECT_PATH/symbols
+
+Note that various helper scripts can be found on the web to automate these
+steps.
+
+IV. Verifying the Android build library:
+========================================
+
+If you modify Google Breakpad and want to check that it still works correctly
+on Android, please run the android/run-checks.sh script which will do all
+necessary verifications for you. This includes:
+
+  - Rebuilding the full host binaries.
+  - Rebuilding the full Android binaries with configure/make.
+  - Rebuilding the client library unit tests, and running them on a device.
+  - Rebuilding the client library with ndk-build.
+  - Building, installing and running a test crasher program on a device.
+  - Extracting the corresponding minidump, dumping the test program symbols
+    and generating a stack trace.
+  - Checking the generated stack trace for valid source locations.
+
+For more details, please run:
+
+  android/run-checks.sh --help-all

toolkit/crashreporter/google-breakpad/android/common-functions.sh

@@ -0,0 +1,372 @@
+# Copyright (c) 2012 Google Inc.
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+#     * Redistributions of source code must retain the above copyright
+# notice, this list of conditions and the following disclaimer.
+#     * Redistributions in binary form must reproduce the above
+# copyright notice, this list of conditions and the following disclaimer
+# in the documentation and/or other materials provided with the
+# distribution.
+#     * Neither the name of Google Inc. nor the names of its
+# contributors may be used to endorse or promote products derived from
+# this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+# Collection of common shell functions for 'run-checks.sh' et 'test-shell.sh'
+
+# All internal variables and functions use an underscore as a prefix
+# (e.g. _VERBOSE, _ALL_CLEANUPS, etc..).
+
+# Sanitize the environment
+export LANG=C
+export LC_ALL=C
+
+if [ "$BASH_VERSION" ]; then
+  set -o posix
+fi
+
+# Utility functions
+
+_ALL_CLEANUPS=
+
+# Register a function to be called when the script exits, even in case of
+# Ctrl-C, logout, etc.
+# $1: function name.
+atexit () {
+  if [ -z "$_ALL_CLEANUPS" ]; then
+    _ALL_CLEANUPS=$1
+    # Ensure a clean exit when the script is:
+    #  - Exiting normally (EXIT)
+    #  - Interrupted by Ctrl-C (INT)
+    #  - Interrupted by log out (HUP)
+    #  - Being asked to quit nicely (TERM)
+    #  - Being asked to quit and dump core (QUIT)
+    trap "_exit_cleanups \$?" EXIT INT HUP QUIT TERM
+  else
+    _ALL_CLEANUPS="$_ALL_CLEANUPS $1"
+  fi
+}
+
+# Called on exit if at least one function was registered with atexit
+# $1: final exit status code
+_exit_cleanups () {
+  local CLEANUP CLEANUPS
+  # Ignore calls to atexit during cleanups
+  CLEANUPS=$_ALL_CLEANUPS
+  _ALL_CLEANUPS=
+  for CLEANUP in $CLEANUPS; do
+    ($CLEANUP)
+  done
+  exit "$@"
+}
+
+
+
+
+# Dump a panic message then exit.
+# $1+: message
+panic () {
+  echo "ERROR: $@" >&2
+  exit 1
+}
+
+# If the previous command failed, dump a panic message then exit.
+# $1+: message.
+fail_panic () {
+  if [ $? != 0 ]; then
+    panic "$@"
+  fi;
+}
+
+_VERBOSE=0
+
+# Increase verbosity for dump/log/run/run2 functions
+increase_verbosity () {
+  _VERBOSE=$(( $_VERBOSE + 1 ))
+}
+
+# Decrease verbosity
+decrease_verbosity () {
+  _VERBOSE=$(( $_VERBOSE - 1 ))
+}
+
+# Returns success iff verbosity level is higher than a specific value
+# $1: verbosity level
+verbosity_is_higher_than () {
+  [ "$_VERBOSE" -gt "$1" ]
+}
+
+# Returns success iff verbosity level is lower than a specific value
+# $1: verbosity level
+verbosity_is_lower_than () {
+  [ "$_VERBOSE" -le "$1" ]
+}
+
+# Dump message to stdout, unless verbosity is < 0, i.e. --quiet was called
+# $1+: message
+dump () {
+  if [ "$_VERBOSE" -ge 0 ]; then
+    printf "%s\n" "$*"
+  fi
+}
+
+# If --verbose was used, dump a message to stdout.
+# $1+: message
+log () {
+  if [ "$_VERBOSE" -ge 1 ]; then
+    printf "%s\n" "$*"
+  fi
+}
+
+_RUN_LOG=
+
+# Set a run log file that can be used to collect the output of commands that
+# are not displayed.
+set_run_log () {
+  _RUN_LOG=$1
+}
+
+# Run a command. Output depends on $_VERBOSE:
+#   $_VERBOSE <= 0:  Run command, store output into the run log
+#   $_VERBOSE >= 1:  Dump command, run it, output goest to stdout
+# Note: Ideally, the command's output would go to the run log for $_VERBOSE >= 1
+#       but the 'tee' tool doesn't preserve the status code of its input pipe
+#       in case of error.
+run () {
+  local LOGILE
+  if [ "$_RUN_LOG" ]; then
+    LOGFILE=$_RUN_LOG
+  else
+    LOGFILE=/dev/null
+  fi
+
+  if [ "$_VERBOSE" -ge 1 ]; then
+    echo "COMMAND: $@"
+    "$@"
+  else
+    "$@" >>$LOGFILE 2>&1
+  fi
+}
+
+# Same as run(), but only dump command output for $_VERBOSE >= 2
+run2 () {
+  local LOGILE
+  if [ "$_RUN_LOG" ]; then
+    LOGFILE=$_RUN_LOG
+  else
+    LOGFILE=/dev/null
+  fi
+
+  if [ "$_VERBOSE" -ge 1 ]; then
+    echo "COMMAND: $@"
+  fi
+  if [ "$_VERBOSE" -ge 2 ]; then
+    "$@"
+  else
+    "$@" >>$LOGFILE 2>&1
+  fi
+}
+
+# Extract number of cores to speed up the builds
+# Out: number of CPU cores
+get_core_count () {
+  case $(uname -s) in
+    Linux)
+      grep -c -e '^processor' /proc/cpuinfo
+      ;;
+    Darwin)
+      sysctl -n hw.ncpu
+      ;;
+    CYGWIN*|*_NT-*)
+      echo $NUMBER_OF_PROCESSORS
+      ;;
+    *)
+      echo 1
+      ;;
+  esac
+}
+
+
+# Check for the Android ADB program.
+#
+# On success, return nothing, but updates internal variables so later calls to
+# adb_shell, adb_push, etc.. will work. You can get the path to the ADB program
+# with adb_get_program if needed.
+#
+# On failure, returns 1, and updates the internal adb error message, which can
+# be retrieved with adb_get_error.
+#
+# $1: optional ADB program path.
+# Return: success or failure.
+_ADB=
+_ADB_STATUS=
+_ADB_ERROR=
+
+adb_check () {
+  # First, try to find the executable in the path, or the SDK install dir.
+  _ADB=$1
+  if [ -z "$_ADB" ]; then
+    _ADB=$(which adb 2>/dev/null)
+    if [ -z "$_ADB" -a "$ANDROID_SDK_ROOT" ]; then
+      _ADB=$ANDROID_SDK_ROOT/platform-tools/adb
+      if [ ! -f "$_ADB" ]; then
+        _ADB=
+      fi
+    fi
+    if [ -z "$_ADB" ]; then
+      _ADB_STATUS=1
+      _ADB_ERROR="The Android 'adb' tool is not in your path."
+      return 1
+    fi
+  fi
+
+  log "Found ADB program: $_ADB"
+
+  # Check that it works correctly
+  local ADB_VERSION
+  ADB_VERSION=$("$_ADB" version 2>/dev/null)
+  case $ADB_VERSION in
+    "Android Debug Bridge "*) # Pass
+      log "Found ADB version: $ADB_VERSION"
+      ;;
+    *) # Fail
+      _ADB_ERROR="Your ADB binary reports a bad version ($ADB_VERSION): $_ADB"
+      _ADB_STATUS=1
+      return 1
+  esac
+
+  _ADB_STATUS=0
+  return 0
+}
+
+
+# Return the path to the Android ADB program, if correctly detected.
+# On failure, return the empty string.
+# Out: ADB program path (or empty on failure)
+# Return: success or failure.
+adb_get_program () {
+  # Return cached value as soon as possible.
+  if [ -z "$_ADB_STATUS" ]; then
+    adb_check $1
+  fi
+  echo "$_ADB"
+  return $_ADB_STATUS
+}
+
+# Return the error corresponding to the last ADB function failure.
+adb_get_error () {
+  echo "$_ADB_ERROR"
+}
+
+# Check that there is one device connected through ADB.
+# In case of failure, use adb_get_error to know why this failed.
+# $1: Optional adb program path
+# Return: success or failure.
+_ADB_DEVICE=
+_ADB_DEVICE_STATUS=
+adb_check_device () {
+  if [ "$_ADB_DEVICE_STATUS" ]; then
+    return $_ADB_DEVICE_STATUS
+  fi
+
+  # Check for ADB.
+  if ! adb_check $1; then
+    _ADB_DEVICE_STATUS=$_ADB_STATUS
+    return 1
+  fi
+
+  local ADB_DEVICES NUM_DEVICES FINGERPRINT
+
+  # Count the number of connected devices.
+  ADB_DEVICES=$("$_ADB" devices 2>/dev/null | awk '$2 == "device" { print $1; }')
+  NUM_DEVICES=$(echo "$ADB_DEVICES" | wc -l)
+  case $NUM_DEVICES in
+    0)
+      _ADB_ERROR="No Android device connected. Please connect one to your machine."
+      _ADB_DEVICE_STATUS=1
+      return 1
+      ;;
+    1) # Pass
+      # Ensure the same device will be called in later adb_shell calls.
+      export ANDROID_SERIAL=$ADB_DEVICES
+      ;;
+    *) # 2 or more devices.
+      if [ "$ANDROID_SERIAL" ]; then
+        ADB_DEVICES=$ANDROID_SERIAL
+        NUM_DEVICES=1
+      else
+        _ADB_ERROR="More than one Android device connected. \
+Please define ANDROID_SERIAL in your environment"
+        _ADB_DEVICE_STATUS=1
+        return 1
+      fi
+      ;;
+  esac
+
+  _ADB_DEVICE_STATUS=0
+  _ADB_DEVICE=$ADB_DEVICES
+
+  FINGERPRINT=$(adb_shell getprop ro.build.fingerprint)
+  log "Using ADB device: $ANDROID_SERIAL ($FINGERPRINT)"
+  return 0
+}
+
+# The 'adb shell' command is pretty hopeless, try to make sense of it by:
+#   1/ Removing trailing \r from line endings.
+#   2/ Ensuring the function returns the command's status code.
+#
+# $1+: Command
+# Out: command output (stdout + stderr combined)
+# Return: command exit status
+adb_shell () {
+  local RET ADB_LOG
+  # Check for ADB device.
+  adb_check_device || return 1
+  ADB_LOG=$(mktemp "${TMPDIR:-/tmp}/adb-XXXXXXXX")
+  "$_ADB" shell "$@" ";" echo \$? > "$ADB_LOG" 2>&1
+  sed -i -e 's![[:cntrl:]]!!g' "$ADB_LOG"  # Remove \r.
+  RET=$(sed -e '$!d' "$ADB_LOG")           # Last line contains status code.
+  sed -e '$d' "$ADB_LOG"                   # Print everything except last line.
+  rm -f "$ADB_LOG"
+  return $RET
+}
+
+# Push a file to a device.
+# $1: source file path
+# $2: device target file path
+# Return: success or failure.
+adb_push () {
+  adb_check_device || return 1
+  run "$_ADB" push "$1" "$2"
+}
+
+# Pull a file from a device
+# $1: device file path
+# $2: target host file path
+# Return: success or failure.
+adb_pull () {
+  adb_check_device || return 1
+  run "$_ADB" pull "$1" "$2"
+}
+
+# Same as adb_push, but will panic if the operations didn't succeed.
+adb_install () {
+  adb_push "$@"
+  fail_panic "Failed to install $1 to the Android device at $2"
+}
+

toolkit/crashreporter/google-breakpad/android/google_breakpad/Android.mk

@@ -0,0 +1,104 @@
+# Copyright (c) 2012, Google Inc.
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+#     * Redistributions of source code must retain the above copyright
+# notice, this list of conditions and the following disclaimer.
+#     * Redistributions in binary form must reproduce the above
+# copyright notice, this list of conditions and the following disclaimer
+# in the documentation and/or other materials provided with the
+# distribution.
+#     * Neither the name of Google Inc. nor the names of its
+# contributors may be used to endorse or promote products derived from
+# this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+# ndk-build module definition for the Google Breakpad client library
+#
+# To use this file, do the following:
+#
+#   1/ Include this file from your own Android.mk, either directly
+#      or with through the NDK's import-module function.
+#
+#   2/ Use the client static library in your project with:
+#
+#      LOCAL_STATIC_LIBRARIES += breakpad_client
+#
+#   3/ In your source code, include "src/client/linux/exception_handler.h"
+#      and use the Linux instructions to use it.
+#
+# This module works with either the STLport or GNU libstdc++, but you need
+# to select one in your Application.mk
+#
+
+# Sanity check. We can only build for ARM for now.
+ifneq (,$(filter-out armeabi armeabi-v7a x86,$(TARGET_ARCH_ABI)))
+$(error Sorry, Google Breakpad only works on Android ARM and x86 for now!)
+endif
+
+# The top Google Breakpad directory.
+# We assume this Android.mk to be under 'android/google_breakpad'
+
+LOCAL_PATH := $(call my-dir)/../..
+
+# Defube the client library module, as a simple static library that
+# exports the right include path / linker flags to its users.
+
+include $(CLEAR_VARS)
+
+LOCAL_MODULE := breakpad_client
+
+LOCAL_CPP_EXTENSION := .cc
+
+# Breakpad uses inline ARM assembly that requires the library
+# to be built in ARM mode. Otherwise, the build will fail with
+# cryptic assembler messages like:
+#   Compile++ thumb  : google_breakpad_client <= crash_generation_client.cc
+#   /tmp/cc8aMSoD.s: Assembler messages:
+#   /tmp/cc8aMSoD.s:132: Error: invalid immediate: 288 is out of range
+#   /tmp/cc8aMSoD.s:244: Error: invalid immediate: 296 is out of range
+LOCAL_ARM_MODE := arm
+
+# List of client source files, directly taken from Makefile.am
+LOCAL_SRC_FILES := \
+    src/client/linux/crash_generation/crash_generation_client.cc \
+    src/client/linux/handler/exception_handler.cc \
+    src/client/linux/handler/minidump_descriptor.cc \
+    src/client/linux/log/log.cc \
+    src/client/linux/minidump_writer/linux_dumper.cc \
+    src/client/linux/minidump_writer/linux_ptrace_dumper.cc \
+    src/client/linux/minidump_writer/minidump_writer.cc \
+    src/client/minidump_file_writer.cc \
+    src/common/android/breakpad_getcontext.S \
+    src/common/convert_UTF.c \
+    src/common/md5.cc src/common/string_conversion.cc \
+    src/common/linux/elfutils.cc \
+    src/common/linux/file_id.cc \
+    src/common/linux/guid_creator.cc \
+    src/common/linux/linux_libc_support.cc \
+    src/common/linux/memory_mapped_file.cc \
+    src/common/linux/safe_readlink.cc
+
+LOCAL_C_INCLUDES        := $(LOCAL_PATH)/src/common/android/include \
+                           $(LOCAL_PATH)/src
+
+LOCAL_EXPORT_C_INCLUDES := $(LOCAL_C_INCLUDES)
+LOCAL_EXPORT_LDLIBS     := -llog
+
+include $(BUILD_STATIC_LIBRARY)
+
+# Done.

toolkit/crashreporter/google-breakpad/android/run-checks.sh

@@ -0,0 +1,547 @@
+#!/bin/sh
+# Copyright (c) 2012 Google Inc.
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+#     * Redistributions of source code must retain the above copyright
+# notice, this list of conditions and the following disclaimer.
+#     * Redistributions in binary form must reproduce the above
+# copyright notice, this list of conditions and the following disclaimer
+# in the documentation and/or other materials provided with the
+# distribution.
+#     * Neither the name of Google Inc. nor the names of its
+# contributors may be used to endorse or promote products derived from
+# this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+# Sanitize the environment
+export LANG=C
+export LC_ALL=C
+
+if [ "$BASH_VERSION" ]; then
+  set -o posix
+fi
+
+PROGDIR=$(dirname "$0")
+PROGDIR=$(cd "$PROGDIR" && pwd)
+PROGNAME=$(basename "$0")
+
+. $PROGDIR/common-functions.sh
+
+DEFAULT_ABI="armeabi"
+VALID_ABIS="armeabi armeabi-v7a x86 mips"
+
+ABI=
+ADB=
+ALL_TESTS=
+ENABLE_M32=
+HELP=
+HELP_ALL=
+NDK_DIR=
+NO_CLEANUP=
+NO_DEVICE=
+NUM_JOBS=$(get_core_count)
+TMPDIR=
+
+for opt do
+  # The following extracts the value if the option is like --name=<value>.
+  optarg=$(expr -- $opt : '^--[^=]*=\(.*\)$')
+  case $opt in
+    --abi=*) ABI=$optarg;;
+    --adb=*) ADB=$optarg;;
+    --all-tests) ALL_TESTS=true;;
+    --enable-m32) ENABLE_M32=true;;
+    --help|-h|-?) HELP=TRUE;;
+    --help-all) HELP_ALL=true;;
+    --jobs=*) NUM_JOBS=$optarg;;
+    --ndk-dir=*) NDK_DIR=$optarg;;
+    --tmp-dir=*) TMPDIR=$optarg;;
+    --no-cleanup) NO_CLEANUP=true;;
+    --no-device) NO_DEVICE=true;;
+    --quiet) decrease_verbosity;;
+    --verbose) increase_verbosity;;
+    -*) panic "Invalid option '$opt', see --help for details.";;
+    *) panic "This script doesn't take any parameters. See --help for details."
+       ;;
+  esac
+done
+
+if [ "$HELP" -o "$HELP_ALL" ]; then
+  echo "\
+  Usage: $PROGNAME [options]
+
+  This script is used to check that your Google Breakpad source tree can
+  be properly built for Android, and that the client library and host tools
+  work properly together.
+"
+  if [ "$HELP_ALL" ]; then
+    echo "\
+  In more details, this script will:
+
+  - Rebuild the host version of Google Breakpad in a temporary
+    directory (with the Auto-tools based build system).
+
+  - Rebuild the Android client library with the Google Breakpad build
+    system (using autotools/configure). This requires that you define
+    ANDROID_NDK_ROOT in your environment to point to a valid Android NDK
+    installation directory, or use the --ndk-dir=<path> option.
+
+  - Rebuild the Android client library and a test crashing program with the
+    Android NDK build system (ndk-build).
+
+  - Require an Android device connected to your machine, and the 'adb'
+    tool in your path. They are used to:
+
+      - Install and  run a test crashing program.
+      - Extract the corresponding minidump from the device.
+      - Dump the symbols from the test program on the host with 'dump_syms'
+      - Generate a stack trace with 'minidump_stackwalk'
+      - Check the stack trace content for valid source file locations.
+
+    You can however skip this requirement and only test the builds by using
+    the --no-device flag.
+
+    By default, all generated files will be created in a temporary directory
+    that is removed when the script completion. If you want to inspect the
+    files, use the --no-cleanup option.
+
+    Finally, use --verbose to increase the verbosity level, this will help
+    you see which exact commands are being issues and their result. Use the
+    flag twice for even more output. Use --quiet to decrease verbosity
+    instead and run the script silently.
+
+    If you have a device connected, the script will probe it to determine
+    its primary CPU ABI, and build the test program for it. You can however
+    use the --abi=<name> option to override this (this can be useful to check
+    the secondary ABI, e.g. using --abi=armeabi to check that such a program
+    works correctly on an ARMv7-A device).
+
+    If you don't have a device connected, the test program will be built (but
+    not run) with the default '$DEFAULT_ABI' ABI. Again, you can use
+    --abi=<name> to override this. Valid ABI names are:
+
+        $VALID_ABIS
+
+    The script will only run the client library unit test on the device
+    by default. You can use --all-tests to also build and run the unit
+    tests for the Breakpad tools and processor, but be warned that this
+    adds several minutes of testing time. --all-tests will also run the
+    host unit tests suite.
+"
+
+  fi  # HELP_ALL
+
+  echo "\
+  Valid options:
+
+      --help|-h|-?     Display this message.
+      --help-all       Display extended help.
+      --enable-m32     Build 32-bit version of host tools.
+      --abi=<name>     Specify target CPU ABI [auto-detected].
+      --jobs=<count>   Run <count> build tasks in parallel [$NUM_JOBS].
+      --ndk-dir=<path> Specify NDK installation directory.
+      --tmp-dir=<path> Specify temporary directory (will be wiped-out).
+      --adb=<path>     Specify adb program path.
+      --no-cleanup     Don't remove temporary directory after completion.
+      --no-device      Do not try to detect devices, nor run crash test.
+      --all-tests      Run all unit tests (i.e. tools and processor ones too).
+      --verbose        Increase verbosity.
+      --quiet          Decrease verbosity."
+
+  exit 0
+fi
+
+TESTAPP_DIR=$PROGDIR/sample_app
+
+# Select NDK install directory.
+if [ -z "$NDK_DIR" ]; then
+  if [ -z "$ANDROID_NDK_ROOT" ]; then
+    panic "Please define ANDROID_NDK_ROOT in your environment, or use \
+--ndk-dir=<path>."
+  fi
+  NDK_DIR="$ANDROID_NDK_ROOT"
+  log "Found NDK directory: $NDK_DIR"
+else
+  log "Using NDK directory: $NDK_DIR"
+fi
+# Small sanity check.
+NDK_BUILD="$NDK_DIR/ndk-build"
+if [ ! -f "$NDK_BUILD" ]; then
+  panic "Your NDK directory is not valid (missing ndk-build): $NDK_DIR"
+fi
+
+# Ensure the temporary directory is deleted on exit, except if the --no-cleanup
+# option is used.
+
+clean_tmpdir () {
+  if [ "$TMPDIR" ]; then
+    if [ -z "$NO_CLEANUP" ]; then
+      log "Cleaning up: $TMPDIR"
+      rm -rf "$TMPDIR"
+    else
+      dump "Temporary directory contents preserved: $TMPDIR"
+    fi
+  fi
+  exit "$@"
+}
+
+atexit clean_tmpdir
+
+# If --tmp-dir=<path> is not used, create a temporary directory.
+# Otherwise, start by cleaning up the user-provided path.
+if [ -z "$TMPDIR" ]; then
+  TMPDIR=$(mktemp -d /tmp/$PROGNAME.XXXXXXXX)
+  fail_panic "Can't create temporary directory!"
+  log "Using temporary directory: $TMPDIR"
+else
+  if [ ! -d "$TMPDIR" ]; then
+    mkdir -p "$TMPDIR"
+    fail_panic "Can't create temporary directory: $TMPDIR"
+  else
+    log "Cleaning up temporary directory: $TMPDIR"
+    rm -rf "$TMPDIR"/*
+    fail_panic "Cannot cleanup temporary directory!"
+  fi
+fi
+
+if [ -z "$NO_DEVICE" ]; then
+  if ! adb_check_device $ADB; then
+    echo "$(adb_get_error)"
+    echo "Use --no-device to build the code without running any tests."
+    exit 1
+  fi
+fi
+
+BUILD_LOG="$TMPDIR/build.log"
+RUN_LOG="$TMPDIR/run.log"
+CRASH_LOG="$TMPDIR/crash.log"
+
+set_run_log "$RUN_LOG"
+
+TMPHOST="$TMPDIR/host-local"
+
+cd "$TMPDIR"
+
+# Build host version of the tools
+dump "Building host binaries."
+CONFIGURE_FLAGS=
+if [ "$ENABLE_M32" ]; then
+  CONFIGURE_FLAGS="$CONFIGURE_FLAGS --enable-m32"
+fi
+(
+  run mkdir "$TMPDIR/build-host" &&
+  run cd "$TMPDIR/build-host" &&
+  run2 "$PROGDIR/../configure" --prefix="$TMPHOST" $CONFIGURE_FLAGS &&
+  run2 make -j$NUM_JOBS install
+)
+fail_panic "Can't build host binaries!"
+
+if [ "$ALL_TESTS" ]; then
+  dump "Running host unit tests."
+  (
+    run cd "$TMPDIR/build-host" &&
+    run2 make -j$NUM_JOBS check
+  )
+  fail_panic "Host unit tests failed!!"
+fi
+
+TMPBIN=$TMPHOST/bin
+
+# Generate a stand-alone NDK toolchain
+
+# Extract CPU ABI and architecture from device, if any.
+if adb_check_device; then
+  DEVICE_ABI=$(adb_shell getprop ro.product.cpu.abi)
+  DEVICE_ABI2=$(adb_shell getprop ro.product.cpu.abi2)
+  if [ -z "$DEVICE_ABI" ]; then
+    panic "Can't extract ABI from connected device!"
+  fi
+  if [ "$DEVICE_ABI2" ]; then
+    dump "Found device ABIs: $DEVICE_ABI $DEVICE_ABI2"
+  else
+    dump "Found device ABI: $DEVICE_ABI"
+    DEVICE_ABI2=$DEVICE_ABI
+  fi
+
+  # If --abi=<name> is used, check that the device supports it.
+  if [ "$ABI" -a "$DEVICE_ABI" != "$ABI" -a "$DEVICE_ABI2" != "$ABI" ]; then
+    dump  "ERROR: Device ABI(s) do not match --abi command-line value ($ABI)!"
+    panic "Please use --no-device to skip device tests."
+  fi
+
+  if [ -z "$ABI" ]; then
+    ABI=$DEVICE_ABI
+    dump "Using CPU ABI: $ABI (device)"
+  else
+    dump "Using CPU ABI: $ABI (command-line)"
+  fi
+else
+  if [ -z "$ABI" ]; then
+    # No device connected, choose default ABI
+    ABI=$DEFAULT_ABI
+    dump "Using CPU ABI: $ABI (default)"
+  else
+    dump "Using CPU ABI: $ABI (command-line)"
+  fi
+fi
+
+# Check the ABI value
+VALID=
+for VALID_ABI in $VALID_ABIS; do
+  if [ "$ABI" = "$VALID_ABI" ]; then
+    VALID=true
+    break
+  fi
+done
+
+if [ -z "$VALID" ]; then
+  panic "Unknown CPU ABI '$ABI'. Valid values are: $VALID_ABIS"
+fi
+
+# Extract architecture name from ABI
+case $ABI in
+  armeabi*) ARCH=arm;;
+  *) ARCH=$ABI;;
+esac
+
+# Extract GNU configuration name
+case $ARCH in
+  arm)
+    GNU_CONFIG=arm-linux-androideabi
+    ;;
+  x86)
+    GNU_CONFIG=i686-linux-android
+    ;;
+  *)
+    GNU_CONFIG="$ARCH-linux-android"
+    ;;
+esac
+
+# Generate standalone NDK toolchain installation
+NDK_STANDALONE="$TMPDIR/ndk-$ARCH-toolchain"
+echo "Generating NDK standalone toolchain installation"
+mkdir -p "$NDK_STANDALONE"
+# NOTE: The --platform=android-9 is required to provide <regex.h> for GTest.
+run "$NDK_DIR/build/tools/make-standalone-toolchain.sh" \
+      --arch="$ARCH" \
+      --platform=android-9 \
+      --install-dir="$NDK_STANDALONE"
+fail_panic "Can't generate standalone NDK toolchain installation!"
+
+# Rebuild the client library, processor and tools with the auto-tools based
+# build system. Even though it's not going to be used, this checks that this
+# still works correctly.
+echo "Building full Android binaries with configure/make"
+TMPTARGET="$TMPDIR/target-local"
+(
+  PATH="$NDK_STANDALONE/bin:$PATH"
+  run mkdir "$TMPTARGET" &&
+  run mkdir "$TMPDIR"/build-target &&
+  run cd "$TMPDIR"/build-target &&
+  run2 "$PROGDIR"/../configure --prefix="$TMPTARGET" \
+                               --host="$GNU_CONFIG" &&
+  run2 make -j$NUM_JOBS install
+)
+fail_panic "Could not rebuild Android binaries!"
+
+# Build and/or run unit test suite.
+# If --no-device is used, only rebuild it, otherwise, run in on the
+# connected device.
+if [ "$NO_DEVICE" ]; then
+  ACTION="Building"
+  # This is a trick to force the Makefile to ignore running the scripts.
+  TESTS_ENVIRONMENT="TESTS_ENVIRONMENT=true"
+else
+  ACTION="Running"
+  TESTS_ENVIRONMENT=
+fi
+if [ "$ALL_TESTS" ]; then
+  dump "$ACTION full Android unit tests."
+else
+  dump "$ACTION Android client library unit tests."
+fi
+
+(
+  PATH="$NDK_STANDALONE/bin:$PATH"
+  run cd "$TMPDIR"/build-target &&
+  if [ -z "$ALL_TESTS" ]; then
+    # Reconfigure to avoid building the unit tests for the tools
+    # and processor, unless --all-tests is used.
+    run2 "$PROGDIR"/../configure --prefix="$TMPTARGET" \
+                                  --host="$GNU_CONFIG" \
+                                  --disable-tools \
+                                  --disable-processor
+  fi &&
+  run make -j$NUM_JOBS check $TESTS_ENVIRONMENT
+)
+if [ -z "$NO_DEVICE" ] && verbosity_is_lower_than 2; then
+  dump "  Unit tests failed as expected. Use --verbose to see results."
+fi
+
+# Copy sources to temporary directory
+PROJECT_DIR=$TMPDIR/project
+dump "Copying test program sources to: $PROJECT_DIR"
+run cp -r "$TESTAPP_DIR" "$PROJECT_DIR" &&
+run rm -rf "$PROJECT_DIR/obj" &&
+run rm -rf "$PROJECT_DIR/libs"
+fail_panic "Could not copy test program sources to: $PROJECT_DIR"
+
+# Build the test program with ndk-build.
+dump "Building test program with ndk-build"
+export NDK_MODULE_PATH="$PROGDIR"
+NDK_BUILD_FLAGS="-j$NUM_JOBS"
+if verbosity_is_higher_than 1; then
+  NDK_BUILD_FLAGS="$NDK_BUILD_FLAGS NDK_LOG=1 V=1"
+fi
+run "$NDK_DIR/ndk-build" -C "$PROJECT_DIR" $NDK_BUILD_FLAGS APP_ABI=$ABI
+fail_panic "Can't build test program!"
+
+# Unless --no-device was used, stop right here if ADB isn't in the path,
+# or there is no connected device.
+if [ "$NO_DEVICE" ]; then
+  dump "Done. Please connect a device to run all tests!"
+  clean_exit 0
+fi
+
+# Push the program to the device.
+TESTAPP=test_google_breakpad
+TESTAPP_FILE="$PROJECT_DIR/libs/$ABI/test_google_breakpad"
+if [ ! -f "$TESTAPP_FILE" ]; then
+  panic "Device requires '$ABI' binaries. None found!"
+fi
+
+# Run the program there
+dump "Installing test program on device"
+DEVICE_TMP=/data/local/tmp
+adb_push "$TESTAPP_FILE" "$DEVICE_TMP/"
+fail_panic "Cannot push test program to device!"
+
+dump "Running test program on device"
+adb_shell cd "$DEVICE_TMP" "&&" ./$TESTAPP > "$CRASH_LOG" 2>/dev/null
+if [ $? = 0 ]; then
+  panic "Test program did *not* crash as expected!"
+fi
+if verbosity_is_higher_than 0; then
+  echo -n "Crash log: "
+  cat "$CRASH_LOG"
+fi
+
+# Extract minidump from device
+MINIDUMP_NAME=$(awk '$1 == "Dump" && $2 == "path:" { print $3; }' "$CRASH_LOG")
+MINIDUMP_NAME=$(basename "$MINIDUMP_NAME")
+if [ -z "$MINIDUMP_NAME" ]; then
+  panic "Test program didn't write minidump properly!"
+fi
+
+dump "Extracting minidump: $MINIDUMP_NAME"
+adb_pull "$DEVICE_TMP/$MINIDUMP_NAME" .
+fail_panic "Can't extract minidump!"
+
+dump "Parsing test program symbols"
+if verbosity_is_higher_than 1; then
+  log "COMMAND: $TMPBIN/dump_syms \
+                $PROJECT_DIR/obj/local/$ABI/$TESTAPP >$TESTAPP.sym"
+fi
+"$TMPBIN/dump_syms" "$PROJECT_DIR/obj/local/$ABI/$TESTAPP" > $TESTAPP.sym
+fail_panic "dump_syms doesn't work!"
+
+VERSION=$(awk '$1 == "MODULE" { print $4; }' $TESTAPP.sym)
+dump "Found module version: $VERSION"
+if [ -z "$VERSION" ]; then
+  echo "ERROR: Can't find proper module version from symbol dump!"
+  head -n5 $TESTAPP.sym
+  clean_exit 1
+fi
+
+run mkdir -p "$TMPDIR/symbols/$TESTAPP/$VERSION"
+run mv $TESTAPP.sym "$TMPDIR/symbols/$TESTAPP/$VERSION/"
+
+dump "Generating stack trace"
+# Don't use 'run' to be able to send stdout and stderr to two different files.
+log "COMMAND: $TMPBIN/minidump_stackwalk $MINIDUMP_NAME symbols"
+"$TMPBIN/minidump_stackwalk" $MINIDUMP_NAME \
+                             "$TMPDIR/symbols" \
+                             > "$BUILD_LOG" 2>>"$RUN_LOG"
+fail_panic "minidump_stackwalk doesn't work!"
+
+dump "Checking stack trace content"
+
+if verbosity_is_higher_than 1; then
+  cat "$BUILD_LOG"
+fi
+
+# The generated stack trace should look like the following:
+#
+# Thread 0 (crashed)
+#  0  test_google_breakpad!crash [test_breakpad.cpp : 17 + 0x4]
+#      r4 = 0x00015530    r5 = 0xbea2cbe4    r6 = 0xffffff38    r7 = 0xbea2cb5c
+#      r8 = 0x00000000    r9 = 0x00000000   r10 = 0x00000000    fp = 0x00000000
+#      sp = 0xbea2cb50    lr = 0x00009025    pc = 0x00008f84
+#     Found by: given as instruction pointer in context
+#  1  test_google_breakpad!main [test_breakpad.cpp : 25 + 0x3]
+#      r4 = 0x00015530    r5 = 0xbea2cbe4    r6 = 0xffffff38    r7 = 0xbea2cb5c
+#      r8 = 0x00000000    r9 = 0x00000000   r10 = 0x00000000    fp = 0x00000000
+#      sp = 0xbea2cb50    pc = 0x00009025
+#     Found by: call frame info
+#  2  libc.so + 0x164e5
+#      r4 = 0x00008f64    r5 = 0xbea2cc34    r6 = 0x00000001    r7 = 0xbea2cc3c
+#      r8 = 0x00000000    r9 = 0x00000000   r10 = 0x00000000    fp = 0x00000000
+#      sp = 0xbea2cc18    pc = 0x400c34e7
+#     Found by: call frame info
+# ...
+#
+# The most important part for us is ensuring that the source location could
+# be extracted, so look at the 'test_breakpad.cpp' references here.
+#
+# First, extract all the lines with test_google_breakpad! in them, and
+# dump the corresponding crash location.
+#
+# Note that if the source location can't be extracted, the second field
+# will only be 'test_google_breakpad' without the exclamation mark.
+#
+LOCATIONS=$(awk '$2 ~ "^test_google_breakpad!.*" { print $3; }' "$BUILD_LOG")
+
+if [ -z "$LOCATIONS" ]; then
+  if verbosity_is_lower_than 1; then
+    cat "$BUILD_LOG"
+  fi
+  panic "No source location found in stack trace!"
+fi
+
+# Now check that they all match "[<source file>"
+BAD_LOCATIONS=
+for LOCATION in $LOCATIONS; do
+  case $LOCATION in
+    # Escape the opening bracket, or some shells like Dash will not
+    # match them properly.
+    \[*.cpp|\[*.cc|\[*.h) # These are valid source locations in our executable
+      ;;
+    *) # Everything else is not!
+      BAD_LOCATIONS="$BAD_LOCATIONS $LOCATION"
+      ;;
+  esac
+done
+
+if [ "$BAD_LOCATIONS" ]; then
+  dump "ERROR: Generated stack trace doesn't contain valid source locations:"
+  cat "$BUILD_LOG"
+  echo "Bad locations are: $BAD_LOCATIONS"
+  exit 1
+fi
+
+echo "All clear! Congratulations."
+

toolkit/crashreporter/google-breakpad/android/sample_app/README

@@ -0,0 +1,32 @@
+This is a sample Android executable that can be used to test the
+Google Breakpad client library on Android.
+
+Its purpose is simply to crash and generate a minidump under /data/local/tmp.
+
+Build instructions:
+
+   cd android/sample_app
+   $NDK/ndk-build
+
+  Where $NDK points to a valid Android NDK installation.
+
+Usage instructions:
+
+   After buildind the test program, send it to a device, then run it as
+   the shell UID:
+
+     adb push libs/armeabi/test_google_breakpad /data/local/tmp
+     adb shell /data/local/tmp/test_google_breakpad
+
+   This will simply crash after dumping the name of the generated minidump
+   file.
+
+   See jni/test_breakpad.cpp for details.
+
+   Use 'armeabi-v7a' instead of 'armeabi' above to test the ARMv7-A version
+   of the binary.
+
+Note:
+   If you plan to use the library in a regular Android application, store
+   the minidump files either to your app-specific directory, or to the SDCard
+   (the latter requiring a specific permission).

toolkit/crashreporter/google-breakpad/android/sample_app/jni/Android.mk

@@ -0,0 +1,44 @@
+# Copyright (c) 2012, Google Inc.
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+#     * Redistributions of source code must retain the above copyright
+# notice, this list of conditions and the following disclaimer.
+#     * Redistributions in binary form must reproduce the above
+# copyright notice, this list of conditions and the following disclaimer
+# in the documentation and/or other materials provided with the
+# distribution.
+#     * Neither the name of Google Inc. nor the names of its
+# contributors may be used to endorse or promote products derived from
+# this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+LOCAL_PATH := $(call my-dir)
+
+include $(CLEAR_VARS)
+LOCAL_MODULE := test_google_breakpad
+LOCAL_SRC_FILES := test_breakpad.cpp
+LOCAL_STATIC_LIBRARIES += breakpad_client
+include $(BUILD_EXECUTABLE)
+
+# If NDK_MODULE_PATH is defined, import the module, otherwise do a direct
+# includes. This allows us to build in all scenarios easily.
+ifneq ($(NDK_MODULE_PATH),)
+  $(call import-module,google_breakpad)
+else
+  include $(LOCAL_PATH)/../../google_breakpad/Android.mk
+endif

toolkit/crashreporter/google-breakpad/android/sample_app/jni/Application.mk

@@ -0,0 +1,31 @@
+# Copyright (c) 2012, Google Inc.
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+#     * Redistributions of source code must retain the above copyright
+# notice, this list of conditions and the following disclaimer.
+#     * Redistributions in binary form must reproduce the above
+# copyright notice, this list of conditions and the following disclaimer
+# in the documentation and/or other materials provided with the
+# distribution.
+#     * Neither the name of Google Inc. nor the names of its
+# contributors may be used to endorse or promote products derived from
+# this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+APP_STL := stlport_static
+APP_ABI := armeabi armeabi-v7a

toolkit/crashreporter/google-breakpad/android/sample_app/jni/test_breakpad.cpp

@@ -0,0 +1,57 @@
+// Copyright (c) 2012, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#include <stdio.h>
+
+#include "client/linux/handler/exception_handler.h"
+#include "client/linux/handler/minidump_descriptor.h"
+
+namespace {
+
+bool DumpCallback(const google_breakpad::MinidumpDescriptor& descriptor,
+                  void* context,
+                  bool succeeded) {
+  printf("Dump path: %s\n", descriptor.path());
+  return succeeded;
+}
+
+void Crash() {
+  volatile int* a = reinterpret_cast<volatile int*>(NULL);
+  *a = 1;
+}
+
+}  // namespace
+
+int main(int argc, char* argv[]) {
+  google_breakpad::MinidumpDescriptor descriptor(".");
+  google_breakpad::ExceptionHandler eh(descriptor, NULL, DumpCallback,
+                                       NULL, true, -1);
+  Crash();
+  return 0;
+}

toolkit/crashreporter/google-breakpad/android/test-shell.sh

@@ -0,0 +1,130 @@
+#!/bin/sh
+#
+# Copyright (c) 2012 Google Inc.
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+#     * Redistributions of source code must retain the above copyright
+# notice, this list of conditions and the following disclaimer.
+#     * Redistributions in binary form must reproduce the above
+# copyright notice, this list of conditions and the following disclaimer
+# in the documentation and/or other materials provided with the
+# distribution.
+#     * Neither the name of Google Inc. nor the names of its
+# contributors may be used to endorse or promote products derived from
+# this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+# A special shell wrapper that can be used to run the Google Breakpad unit
+# tests on a connected Android device.
+#
+# This is designed to be called from the Makefile during 'make check'
+#
+
+PROGDIR=$(dirname "$0")
+PROGNAME=$(basename "$0")
+. $PROGDIR/common-functions.sh
+
+# Extract test program name first.
+TEST_PROGRAM=$1
+shift
+
+if [ -z "$TEST_PROGRAM" ]; then
+  panic "No test program/script name on the command-line!"
+fi
+
+if [ ! -f "$TEST_PROGRAM" ]; then
+  panic "Can't find test program/script: $TEST_PROGRAM"
+fi
+
+# Create test directory on the device
+TEST_DIR=/data/local/tmp/test-google-breakpad
+adb_shell mkdir "$TEST_DIR" || panic "Can't create test directory on device"
+
+# Ensure that it is always removed when the script exits.
+clean_test_dir () {
+  # Don't care about success/failure, use '$ADB shell' directly.
+  adb_shell rm -r "$TEST_DIR"
+}
+
+atexit clean_test_dir
+
+TEST_PROGRAM_NAME=$(basename "$TEST_PROGRAM")
+TEST_PROGRAM_DIR=$(dirname "$TEST_PROGRAM")
+
+# Handle special case(s) here.
+DATA_FILES=
+case $TEST_PROGRAM_NAME in
+  linux_client_unittest)
+    # linux_client_unittest will call another executable at runtime, ensure
+    # it is installed too.
+    adb_install "$TEST_PROGRAM_DIR/linux_dumper_unittest_helper" "$TEST_DIR"
+    # linux_client_unittest loads a shared library at runtime, ensure it is
+    # installed too.
+    adb_install "$TEST_PROGRAM_DIR/linux_client_unittest_shlib" "$TEST_DIR"
+    ;;
+  basic_source_line_resolver_unittest)
+    DATA_FILES="module1.out \
+                module2.out \
+                module3_bad.out \
+                module4_bad.out"
+    ;;
+  exploitability_unittest)
+    DATA_FILES="scii_read_av.dmp \
+                ascii_read_av_block_write.dmp \
+                ascii_read_av_clobber_write.dmp \
+                ascii_read_av_conditional.dmp \
+                ascii_read_av_non_null.dmp \
+                ascii_read_av_then_jmp.dmp \
+                ascii_read_av_xchg_write.dmp \
+                ascii_write_av.dmp \
+                ascii_write_av_arg_to_call.dmp \
+                exec_av_on_stack.dmp \
+                null_read_av.dmp \
+                null_write_av.dmp \
+                read_av.dmp \
+                null_read_av.dmp \
+                write_av_non_null.dmp"
+    ;;
+  fast_source_line_resolver_unittest)
+    DATA_FILES="module0.out \
+                module1.out \
+                module2.out \
+                module3_bad.out \
+                module4_bad.out"
+    ;;
+  minidump_processor_unittest|minidump_unittest)
+    DATA_FILES="src/processor/testdata/minidump2.dmp"
+    ;;
+esac
+
+# Install the data files, their path is relative to the environment
+# variable 'srcdir'
+for FILE in $DATA_FILES; do
+  FILEDIR=src/processor/testdata/$(dirname "$FILE")
+  adb_shell mkdir -p "$TEST_DIR/$FILEDIR"
+  adb_install "${srcdir:-.}/$FILE" "$TEST_DIR"/"$FILE"
+done
+
+# Copy test program to device
+adb_install "$TEST_PROGRAM" "$TEST_DIR"
+
+# Run it
+adb_shell "cd $TEST_DIR && LD_LIBRARY_PATH=. ./$TEST_PROGRAM_NAME $@"
+
+# Note: exiting here will call cleanup_exit which will remove the temporary
+#       files from the device.

toolkit/crashreporter/google-breakpad/autotools/compile

@@ -0,0 +1 @@
+/usr/share/automake-1.11/compile

toolkit/crashreporter/google-breakpad/autotools/config.guess

@@ -1,10 +1,10 @@
 #! /bin/sh
 # Attempt to guess a canonical system name.
 #   Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
-#   2000, 2001, 2002, 2003, 2004, 2005, 2006 Free Software Foundation,
-#   Inc.
+#   2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010,
+#   2011, 2012 Free Software Foundation, Inc.
 
-timestamp='2006-07-02'
+timestamp='2012-06-17'
 
 # This file is free software; you can redistribute it and/or modify it
 # under the terms of the GNU General Public License as published by
@@ -17,9 +17,7 @@ timestamp='2006-07-02'
 # General Public License for more details.
 #
 # You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
-# 02110-1301, USA.
+# along with this program; if not, see <http://www.gnu.org/licenses/>.
 #
 # As a special exception to the GNU General Public License, if you
 # distribute this file as part of a program that contains a
@@ -27,16 +25,16 @@ timestamp='2006-07-02'
 # the same distribution terms that you use for the rest of that program.
 
 
-# Originally written by Per Bothner <per@bothner.com>.
-# Please send patches to <config-patches@gnu.org>.  Submit a context
-# diff and a properly formatted ChangeLog entry.
+# Originally written by Per Bothner.  Please send patches (context
+# diff format) to <config-patches@gnu.org> and include a ChangeLog
+# entry.
 #
 # This script attempts to guess a canonical system name similar to
 # config.sub.  If it succeeds, it prints the system name on stdout, and
 # exits with 0.  Otherwise, it exits with 1.
 #
-# The plan is that this can be called by configure scripts if you
-# don't specify an explicit build system type.
+# You can get the latest version of this script from:
+# http://git.savannah.gnu.org/gitweb/?p=config.git;a=blob_plain;f=config.guess;hb=HEAD
 
 me=`echo "$0" | sed -e 's,.*/,,'`
 
@@ -56,7 +54,8 @@ version="\
 GNU config.guess ($timestamp)
 
 Originally written by Per Bothner.
-Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005
+Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
+2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012
 Free Software Foundation, Inc.
 
 This is free software; see the source for copying conditions.  There is NO
@@ -144,7 +143,7 @@ UNAME_VERSION=`(uname -v) 2>/dev/null` || UNAME_VERSION=unknown
 case "${UNAME_MACHINE}:${UNAME_SYSTEM}:${UNAME_RELEASE}:${UNAME_VERSION}" in
     *:NetBSD:*:*)
 	# NetBSD (nbsd) targets should (where applicable) match one or
-	# more of the tupples: *-*-netbsdelf*, *-*-netbsdaout*,
+	# more of the tuples: *-*-netbsdelf*, *-*-netbsdaout*,
 	# *-*-netbsdecoff* and *-*-netbsd*.  For targets that recently
 	# switched to ELF, *-*-netbsd* would select the old
 	# object file format.  This provides both forward
@@ -161,6 +160,7 @@ case "${UNAME_MACHINE}:${UNAME_SYSTEM}:${UNAME_RELEASE}:${UNAME_VERSION}" in
 	    arm*) machine=arm-unknown ;;
 	    sh3el) machine=shl-unknown ;;
 	    sh3eb) machine=sh-unknown ;;
+	    sh5el) machine=sh5le-unknown ;;
 	    *) machine=${UNAME_MACHINE_ARCH}-unknown ;;
 	esac
 	# The Operating System including object format, if it has switched
@@ -169,7 +169,7 @@ case "${UNAME_MACHINE}:${UNAME_SYSTEM}:${UNAME_RELEASE}:${UNAME_VERSION}" in
 	    arm*|i386|m68k|ns32k|sh3*|sparc|vax)
 		eval $set_cc_for_build
 		if echo __ELF__ | $CC_FOR_BUILD -E - 2>/dev/null \
-			| grep __ELF__ >/dev/null
+			| grep -q __ELF__
 		then
 		    # Once all utilities can be ECOFF (netbsdecoff) or a.out (netbsdaout).
 		    # Return netbsd for either.  FIX?
@@ -179,7 +179,7 @@ case "${UNAME_MACHINE}:${UNAME_SYSTEM}:${UNAME_RELEASE}:${UNAME_VERSION}" in
 		fi
 		;;
 	    *)
-	        os=netbsd
+		os=netbsd
 		;;
 	esac
 	# The OS release
@@ -200,6 +200,10 @@ case "${UNAME_MACHINE}:${UNAME_SYSTEM}:${UNAME_RELEASE}:${UNAME_VERSION}" in
 	# CPU_TYPE-MANUFACTURER-OPERATING_SYSTEM is used.
 	echo "${machine}-${os}${release}"
 	exit ;;
+    *:Bitrig:*:*)
+	UNAME_MACHINE_ARCH=`arch | sed 's/Bitrig.//'`
+	echo ${UNAME_MACHINE_ARCH}-unknown-bitrig${UNAME_RELEASE}
+	exit ;;
     *:OpenBSD:*:*)
 	UNAME_MACHINE_ARCH=`arch | sed 's/OpenBSD.//'`
 	echo ${UNAME_MACHINE_ARCH}-unknown-openbsd${UNAME_RELEASE}
@@ -222,7 +226,7 @@ case "${UNAME_MACHINE}:${UNAME_SYSTEM}:${UNAME_RELEASE}:${UNAME_VERSION}" in
 		UNAME_RELEASE=`/usr/sbin/sizer -v | awk '{print $3}'`
 		;;
 	*5.*)
-	        UNAME_RELEASE=`/usr/sbin/sizer -v | awk '{print $4}'`
+		UNAME_RELEASE=`/usr/sbin/sizer -v | awk '{print $4}'`
 		;;
 	esac
 	# According to Compaq, /usr/sbin/psrinfo has been available on
@@ -268,7 +272,10 @@ case "${UNAME_MACHINE}:${UNAME_SYSTEM}:${UNAME_RELEASE}:${UNAME_VERSION}" in
 	# A Xn.n version is an unreleased experimental baselevel.
 	# 1.2 uses "1.2" for uname -r.
 	echo ${UNAME_MACHINE}-dec-osf`echo ${UNAME_RELEASE} | sed -e 's/^[PVTX]//' | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
-	exit ;;
+	# Reset EXIT trap before exiting to avoid spurious non-zero exit code.
+	exitcode=$?
+	trap '' 0
+	exit $exitcode ;;
     Alpha\ *:Windows_NT*:*)
 	# How do we know it's Interix rather than the generic POSIX subsystem?
 	# Should we change UNAME_MACHINE based on the output of uname instead
@@ -294,7 +301,7 @@ case "${UNAME_MACHINE}:${UNAME_SYSTEM}:${UNAME_RELEASE}:${UNAME_VERSION}" in
 	echo s390-ibm-zvmoe
 	exit ;;
     *:OS400:*:*)
-        echo powerpc-ibm-os400
+	echo powerpc-ibm-os400
 	exit ;;
     arm:RISC*:1.[012]*:*|arm:riscix:1.[012]*:*)
 	echo arm-acorn-riscix${UNAME_RELEASE}
@@ -323,14 +330,33 @@ case "${UNAME_MACHINE}:${UNAME_SYSTEM}:${UNAME_RELEASE}:${UNAME_VERSION}" in
 	case `/usr/bin/uname -p` in
 	    sparc) echo sparc-icl-nx7; exit ;;
 	esac ;;
+    s390x:SunOS:*:*)
+	echo ${UNAME_MACHINE}-ibm-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'`
+	exit ;;
     sun4H:SunOS:5.*:*)
 	echo sparc-hal-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'`
 	exit ;;
     sun4*:SunOS:5.*:* | tadpole*:SunOS:5.*:*)
 	echo sparc-sun-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'`
 	exit ;;
-    i86pc:SunOS:5.*:*)
-	echo i386-pc-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'`
+    i86pc:AuroraUX:5.*:* | i86xen:AuroraUX:5.*:*)
+	echo i386-pc-auroraux${UNAME_RELEASE}
+	exit ;;
+    i86pc:SunOS:5.*:* | i86xen:SunOS:5.*:*)
+	eval $set_cc_for_build
+	SUN_ARCH="i386"
+	# If there is a compiler, see if it is configured for 64-bit objects.
+	# Note that the Sun cc does not turn __LP64__ into 1 like gcc does.
+	# This test works for both compilers.
+	if [ "$CC_FOR_BUILD" != 'no_compiler_found' ]; then
+	    if (echo '#ifdef __amd64'; echo IS_64BIT_ARCH; echo '#endif') | \
+		(CCOPTS= $CC_FOR_BUILD -E - 2>/dev/null) | \
+		grep IS_64BIT_ARCH >/dev/null
+	    then
+		SUN_ARCH="x86_64"
+	    fi
+	fi
+	echo ${SUN_ARCH}-pc-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'`
 	exit ;;
     sun4*:SunOS:6*:*)
 	# According to config.sub, this is the proper way to canonicalize
@@ -374,23 +400,23 @@ case "${UNAME_MACHINE}:${UNAME_SYSTEM}:${UNAME_RELEASE}:${UNAME_VERSION}" in
     # MiNT.  But MiNT is downward compatible to TOS, so this should
     # be no problem.
     atarist[e]:*MiNT:*:* | atarist[e]:*mint:*:* | atarist[e]:*TOS:*:*)
-        echo m68k-atari-mint${UNAME_RELEASE}
+	echo m68k-atari-mint${UNAME_RELEASE}
 	exit ;;
     atari*:*MiNT:*:* | atari*:*mint:*:* | atarist[e]:*TOS:*:*)
 	echo m68k-atari-mint${UNAME_RELEASE}
-        exit ;;
+	exit ;;
     *falcon*:*MiNT:*:* | *falcon*:*mint:*:* | *falcon*:*TOS:*:*)
-        echo m68k-atari-mint${UNAME_RELEASE}
+	echo m68k-atari-mint${UNAME_RELEASE}
 	exit ;;
     milan*:*MiNT:*:* | milan*:*mint:*:* | *milan*:*TOS:*:*)
-        echo m68k-milan-mint${UNAME_RELEASE}
-        exit ;;
+	echo m68k-milan-mint${UNAME_RELEASE}
+	exit ;;
     hades*:*MiNT:*:* | hades*:*mint:*:* | *hades*:*TOS:*:*)
-        echo m68k-hades-mint${UNAME_RELEASE}
-        exit ;;
+	echo m68k-hades-mint${UNAME_RELEASE}
+	exit ;;
     *:*MiNT:*:* | *:*mint:*:* | *:*TOS:*:*)
-        echo m68k-unknown-mint${UNAME_RELEASE}
-        exit ;;
+	echo m68k-unknown-mint${UNAME_RELEASE}
+	exit ;;
     m68k:machten:*:*)
 	echo m68k-apple-machten${UNAME_RELEASE}
 	exit ;;
@@ -460,8 +486,8 @@ EOF
 	echo m88k-motorola-sysv3
 	exit ;;
     AViiON:dgux:*:*)
-        # DG/UX returns AViiON for all architectures
-        UNAME_PROCESSOR=`/usr/bin/uname -p`
+	# DG/UX returns AViiON for all architectures
+	UNAME_PROCESSOR=`/usr/bin/uname -p`
 	if [ $UNAME_PROCESSOR = mc88100 ] || [ $UNAME_PROCESSOR = mc88110 ]
 	then
 	    if [ ${TARGET_BINARY_INTERFACE}x = m88kdguxelfx ] || \
@@ -474,7 +500,7 @@ EOF
 	else
 	    echo i586-dg-dgux${UNAME_RELEASE}
 	fi
- 	exit ;;
+	exit ;;
     M88*:DolphinOS:*:*)	# DolphinOS (SVR3)
 	echo m88k-dolphin-sysv3
 	exit ;;
@@ -531,7 +557,7 @@ EOF
 		echo rs6000-ibm-aix3.2
 	fi
 	exit ;;
-    *:AIX:*:[45])
+    *:AIX:*:[4567])
 	IBM_CPU_ID=`/usr/sbin/lsdev -C -c processor -S available | sed 1q | awk '{ print $1 }'`
 	if /usr/sbin/lsattr -El ${IBM_CPU_ID} | grep ' POWER' >/dev/null 2>&1; then
 		IBM_ARCH=rs6000
@@ -574,52 +600,52 @@ EOF
 	    9000/[678][0-9][0-9])
 		if [ -x /usr/bin/getconf ]; then
 		    sc_cpu_version=`/usr/bin/getconf SC_CPU_VERSION 2>/dev/null`
-                    sc_kernel_bits=`/usr/bin/getconf SC_KERNEL_BITS 2>/dev/null`
-                    case "${sc_cpu_version}" in
-                      523) HP_ARCH="hppa1.0" ;; # CPU_PA_RISC1_0
-                      528) HP_ARCH="hppa1.1" ;; # CPU_PA_RISC1_1
-                      532)                      # CPU_PA_RISC2_0
-                        case "${sc_kernel_bits}" in
-                          32) HP_ARCH="hppa2.0n" ;;
-                          64) HP_ARCH="hppa2.0w" ;;
+		    sc_kernel_bits=`/usr/bin/getconf SC_KERNEL_BITS 2>/dev/null`
+		    case "${sc_cpu_version}" in
+		      523) HP_ARCH="hppa1.0" ;; # CPU_PA_RISC1_0
+		      528) HP_ARCH="hppa1.1" ;; # CPU_PA_RISC1_1
+		      532)                      # CPU_PA_RISC2_0
+			case "${sc_kernel_bits}" in
+			  32) HP_ARCH="hppa2.0n" ;;
+			  64) HP_ARCH="hppa2.0w" ;;
 			  '') HP_ARCH="hppa2.0" ;;   # HP-UX 10.20
-                        esac ;;
-                    esac
+			esac ;;
+		    esac
 		fi
 		if [ "${HP_ARCH}" = "" ]; then
 		    eval $set_cc_for_build
-		    sed 's/^              //' << EOF >$dummy.c
+		    sed 's/^		//' << EOF >$dummy.c
 
-              #define _HPUX_SOURCE
-              #include <stdlib.h>
-              #include <unistd.h>
+		#define _HPUX_SOURCE
+		#include <stdlib.h>
+		#include <unistd.h>
 
-              int main ()
-              {
-              #if defined(_SC_KERNEL_BITS)
-                  long bits = sysconf(_SC_KERNEL_BITS);
-              #endif
-                  long cpu  = sysconf (_SC_CPU_VERSION);
+		int main ()
+		{
+		#if defined(_SC_KERNEL_BITS)
+		    long bits = sysconf(_SC_KERNEL_BITS);
+		#endif
+		    long cpu  = sysconf (_SC_CPU_VERSION);
 
-                  switch (cpu)
-              	{
-              	case CPU_PA_RISC1_0: puts ("hppa1.0"); break;
-              	case CPU_PA_RISC1_1: puts ("hppa1.1"); break;
-              	case CPU_PA_RISC2_0:
-              #if defined(_SC_KERNEL_BITS)
-              	    switch (bits)
-              		{
-              		case 64: puts ("hppa2.0w"); break;
-              		case 32: puts ("hppa2.0n"); break;
-              		default: puts ("hppa2.0"); break;
-              		} break;
-              #else  /* !defined(_SC_KERNEL_BITS) */
-              	    puts ("hppa2.0"); break;
-              #endif
-              	default: puts ("hppa1.0"); break;
-              	}
-                  exit (0);
-              }
+		    switch (cpu)
+			{
+			case CPU_PA_RISC1_0: puts ("hppa1.0"); break;
+			case CPU_PA_RISC1_1: puts ("hppa1.1"); break;
+			case CPU_PA_RISC2_0:
+		#if defined(_SC_KERNEL_BITS)
+			    switch (bits)
+				{
+				case 64: puts ("hppa2.0w"); break;
+				case 32: puts ("hppa2.0n"); break;
+				default: puts ("hppa2.0"); break;
+				} break;
+		#else  /* !defined(_SC_KERNEL_BITS) */
+			    puts ("hppa2.0"); break;
+		#endif
+			default: puts ("hppa1.0"); break;
+			}
+		    exit (0);
+		}
 EOF
 		    (CCOPTS= $CC_FOR_BUILD -o $dummy $dummy.c 2>/dev/null) && HP_ARCH=`$dummy`
 		    test -z "$HP_ARCH" && HP_ARCH=hppa
@@ -639,7 +665,7 @@ EOF
 	    # => hppa64-hp-hpux11.23
 
 	    if echo __LP64__ | (CCOPTS= $CC_FOR_BUILD -E - 2>/dev/null) |
-		grep __LP64__ >/dev/null
+		grep -q __LP64__
 	    then
 		HP_ARCH="hppa2.0w"
 	    else
@@ -710,22 +736,22 @@ EOF
 	exit ;;
     C1*:ConvexOS:*:* | convex:ConvexOS:C1*:*)
 	echo c1-convex-bsd
-        exit ;;
+	exit ;;
     C2*:ConvexOS:*:* | convex:ConvexOS:C2*:*)
 	if getsysinfo -f scalar_acc
 	then echo c32-convex-bsd
 	else echo c2-convex-bsd
 	fi
-        exit ;;
+	exit ;;
     C34*:ConvexOS:*:* | convex:ConvexOS:C34*:*)
 	echo c34-convex-bsd
-        exit ;;
+	exit ;;
     C38*:ConvexOS:*:* | convex:ConvexOS:C38*:*)
 	echo c38-convex-bsd
-        exit ;;
+	exit ;;
     C4*:ConvexOS:*:* | convex:ConvexOS:C4*:*)
 	echo c4-convex-bsd
-        exit ;;
+	exit ;;
     CRAY*Y-MP:*:*:*)
 	echo ymp-cray-unicos${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/'
 	exit ;;
@@ -749,14 +775,14 @@ EOF
 	exit ;;
     F30[01]:UNIX_System_V:*:* | F700:UNIX_System_V:*:*)
 	FUJITSU_PROC=`uname -m | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
-        FUJITSU_SYS=`uname -p | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz' | sed -e 's/\///'`
-        FUJITSU_REL=`echo ${UNAME_RELEASE} | sed -e 's/ /_/'`
-        echo "${FUJITSU_PROC}-fujitsu-${FUJITSU_SYS}${FUJITSU_REL}"
-        exit ;;
+	FUJITSU_SYS=`uname -p | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz' | sed -e 's/\///'`
+	FUJITSU_REL=`echo ${UNAME_RELEASE} | sed -e 's/ /_/'`
+	echo "${FUJITSU_PROC}-fujitsu-${FUJITSU_SYS}${FUJITSU_REL}"
+	exit ;;
     5000:UNIX_System_V:4.*:*)
-        FUJITSU_SYS=`uname -p | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz' | sed -e 's/\///'`
-        FUJITSU_REL=`echo ${UNAME_RELEASE} | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz' | sed -e 's/ /_/'`
-        echo "sparc-fujitsu-${FUJITSU_SYS}${FUJITSU_REL}"
+	FUJITSU_SYS=`uname -p | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz' | sed -e 's/\///'`
+	FUJITSU_REL=`echo ${UNAME_RELEASE} | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz' | sed -e 's/ /_/'`
+	echo "sparc-fujitsu-${FUJITSU_SYS}${FUJITSU_REL}"
 	exit ;;
     i*86:BSD/386:*:* | i*86:BSD/OS:*:* | *:Ascend\ Embedded/OS:*:*)
 	echo ${UNAME_MACHINE}-pc-bsdi${UNAME_RELEASE}
@@ -768,37 +794,48 @@ EOF
 	echo ${UNAME_MACHINE}-unknown-bsdi${UNAME_RELEASE}
 	exit ;;
     *:FreeBSD:*:*)
-	case ${UNAME_MACHINE} in
-	    pc98)
-		echo i386-unknown-freebsd`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'` ;;
+	UNAME_PROCESSOR=`/usr/bin/uname -p`
+	case ${UNAME_PROCESSOR} in
 	    amd64)
 		echo x86_64-unknown-freebsd`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'` ;;
 	    *)
-		echo ${UNAME_MACHINE}-unknown-freebsd`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'` ;;
+		echo ${UNAME_PROCESSOR}-unknown-freebsd`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'` ;;
 	esac
 	exit ;;
     i*:CYGWIN*:*)
 	echo ${UNAME_MACHINE}-pc-cygwin
 	exit ;;
-    i*:MINGW*:*)
+    *:MINGW*:*)
 	echo ${UNAME_MACHINE}-pc-mingw32
 	exit ;;
+    i*:MSYS*:*)
+	echo ${UNAME_MACHINE}-pc-msys
+	exit ;;
     i*:windows32*:*)
-    	# uname -m includes "-pc" on this system.
-    	echo ${UNAME_MACHINE}-mingw32
+	# uname -m includes "-pc" on this system.
+	echo ${UNAME_MACHINE}-mingw32
 	exit ;;
     i*:PW*:*)
 	echo ${UNAME_MACHINE}-pc-pw32
 	exit ;;
-    x86:Interix*:[3456]*)
-	echo i586-pc-interix${UNAME_RELEASE}
-	exit ;;
-    EM64T:Interix*:[3456]*)
-	echo x86_64-unknown-interix${UNAME_RELEASE}
-	exit ;;
+    *:Interix*:*)
+	case ${UNAME_MACHINE} in
+	    x86)
+		echo i586-pc-interix${UNAME_RELEASE}
+		exit ;;
+	    authenticamd | genuineintel | EM64T)
+		echo x86_64-unknown-interix${UNAME_RELEASE}
+		exit ;;
+	    IA64)
+		echo ia64-unknown-interix${UNAME_RELEASE}
+		exit ;;
+	esac ;;
     [345]86:Windows_95:* | [345]86:Windows_98:* | [345]86:Windows_NT:*)
 	echo i${UNAME_MACHINE}-pc-mks
 	exit ;;
+    8664:Windows_NT:*)
+	echo x86_64-pc-mks
+	exit ;;
     i*:Windows_NT*:* | Pentium*:Windows_NT*:*)
 	# How do we know it's Interix rather than the generic POSIX subsystem?
 	# It also conflicts with pre-2.0 versions of AT&T UWIN. Should we
@@ -828,85 +865,13 @@ EOF
     i*86:Minix:*:*)
 	echo ${UNAME_MACHINE}-pc-minix
 	exit ;;
-    arm*:Linux:*:*)
+    aarch64:Linux:*:*)
 	echo ${UNAME_MACHINE}-unknown-linux-gnu
 	exit ;;
-    avr32*:Linux:*:*)
+    aarch64_be:Linux:*:*)
+	UNAME_MACHINE=aarch64_be
 	echo ${UNAME_MACHINE}-unknown-linux-gnu
 	exit ;;
-    cris:Linux:*:*)
-	echo cris-axis-linux-gnu
-	exit ;;
-    crisv32:Linux:*:*)
-	echo crisv32-axis-linux-gnu
-	exit ;;
-    frv:Linux:*:*)
-    	echo frv-unknown-linux-gnu
-	exit ;;
-    ia64:Linux:*:*)
-	echo ${UNAME_MACHINE}-unknown-linux-gnu
-	exit ;;
-    m32r*:Linux:*:*)
-	echo ${UNAME_MACHINE}-unknown-linux-gnu
-	exit ;;
-    m68*:Linux:*:*)
-	echo ${UNAME_MACHINE}-unknown-linux-gnu
-	exit ;;
-    mips:Linux:*:*)
-	eval $set_cc_for_build
-	sed 's/^	//' << EOF >$dummy.c
-	#undef CPU
-	#undef mips
-	#undef mipsel
-	#if defined(__MIPSEL__) || defined(__MIPSEL) || defined(_MIPSEL) || defined(MIPSEL)
-	CPU=mipsel
-	#else
-	#if defined(__MIPSEB__) || defined(__MIPSEB) || defined(_MIPSEB) || defined(MIPSEB)
-	CPU=mips
-	#else
-	CPU=
-	#endif
-	#endif
-EOF
-	eval "`$CC_FOR_BUILD -E $dummy.c 2>/dev/null | sed -n '
-	    /^CPU/{
-		s: ::g
-		p
-	    }'`"
-	test x"${CPU}" != x && { echo "${CPU}-unknown-linux-gnu"; exit; }
-	;;
-    mips64:Linux:*:*)
-	eval $set_cc_for_build
-	sed 's/^	//' << EOF >$dummy.c
-	#undef CPU
-	#undef mips64
-	#undef mips64el
-	#if defined(__MIPSEL__) || defined(__MIPSEL) || defined(_MIPSEL) || defined(MIPSEL)
-	CPU=mips64el
-	#else
-	#if defined(__MIPSEB__) || defined(__MIPSEB) || defined(_MIPSEB) || defined(MIPSEB)
-	CPU=mips64
-	#else
-	CPU=
-	#endif
-	#endif
-EOF
-	eval "`$CC_FOR_BUILD -E $dummy.c 2>/dev/null | sed -n '
-	    /^CPU/{
-		s: ::g
-		p
-	    }'`"
-	test x"${CPU}" != x && { echo "${CPU}-unknown-linux-gnu"; exit; }
-	;;
-    or32:Linux:*:*)
-	echo or32-unknown-linux-gnu
-	exit ;;
-    ppc:Linux:*:*)
-	echo powerpc-unknown-linux-gnu
-	exit ;;
-    ppc64:Linux:*:*)
-	echo powerpc64-unknown-linux-gnu
-	exit ;;
     alpha:Linux:*:*)
 	case `sed -n '/^cpu model/s/^.*: \(.*\)/\1/p' < /proc/cpuinfo` in
 	  EV5)   UNAME_MACHINE=alphaev5 ;;
@@ -916,11 +881,90 @@ EOF
 	  EV6)   UNAME_MACHINE=alphaev6 ;;
 	  EV67)  UNAME_MACHINE=alphaev67 ;;
 	  EV68*) UNAME_MACHINE=alphaev68 ;;
-        esac
-	objdump --private-headers /bin/sh | grep ld.so.1 >/dev/null
+	esac
+	objdump --private-headers /bin/sh | grep -q ld.so.1
 	if test "$?" = 0 ; then LIBC="libc1" ; else LIBC="" ; fi
 	echo ${UNAME_MACHINE}-unknown-linux-gnu${LIBC}
 	exit ;;
+    arm*:Linux:*:*)
+	eval $set_cc_for_build
+	if echo __ARM_EABI__ | $CC_FOR_BUILD -E - 2>/dev/null \
+	    | grep -q __ARM_EABI__
+	then
+	    echo ${UNAME_MACHINE}-unknown-linux-gnu
+	else
+	    if echo __ARM_PCS_VFP | $CC_FOR_BUILD -E - 2>/dev/null \
+		| grep -q __ARM_PCS_VFP
+	    then
+		echo ${UNAME_MACHINE}-unknown-linux-gnueabi
+	    else
+		echo ${UNAME_MACHINE}-unknown-linux-gnueabihf
+	    fi
+	fi
+	exit ;;
+    avr32*:Linux:*:*)
+	echo ${UNAME_MACHINE}-unknown-linux-gnu
+	exit ;;
+    cris:Linux:*:*)
+	echo ${UNAME_MACHINE}-axis-linux-gnu
+	exit ;;
+    crisv32:Linux:*:*)
+	echo ${UNAME_MACHINE}-axis-linux-gnu
+	exit ;;
+    frv:Linux:*:*)
+	echo ${UNAME_MACHINE}-unknown-linux-gnu
+	exit ;;
+    hexagon:Linux:*:*)
+	echo ${UNAME_MACHINE}-unknown-linux-gnu
+	exit ;;
+    i*86:Linux:*:*)
+	LIBC=gnu
+	eval $set_cc_for_build
+	sed 's/^	//' << EOF >$dummy.c
+	#ifdef __dietlibc__
+	LIBC=dietlibc
+	#endif
+EOF
+	eval `$CC_FOR_BUILD -E $dummy.c 2>/dev/null | grep '^LIBC'`
+	echo "${UNAME_MACHINE}-pc-linux-${LIBC}"
+	exit ;;
+    ia64:Linux:*:*)
+	echo ${UNAME_MACHINE}-unknown-linux-gnu
+	exit ;;
+    m32r*:Linux:*:*)
+	echo ${UNAME_MACHINE}-unknown-linux-gnu
+	exit ;;
+    m68*:Linux:*:*)
+	echo ${UNAME_MACHINE}-unknown-linux-gnu
+	exit ;;
+    mips:Linux:*:* | mips64:Linux:*:*)
+	eval $set_cc_for_build
+	sed 's/^	//' << EOF >$dummy.c
+	#undef CPU
+	#undef ${UNAME_MACHINE}
+	#undef ${UNAME_MACHINE}el
+	#if defined(__MIPSEL__) || defined(__MIPSEL) || defined(_MIPSEL) || defined(MIPSEL)
+	CPU=${UNAME_MACHINE}el
+	#else
+	#if defined(__MIPSEB__) || defined(__MIPSEB) || defined(_MIPSEB) || defined(MIPSEB)
+	CPU=${UNAME_MACHINE}
+	#else
+	CPU=
+	#endif
+	#endif
+EOF
+	eval `$CC_FOR_BUILD -E $dummy.c 2>/dev/null | grep '^CPU'`
+	test x"${CPU}" != x && { echo "${CPU}-unknown-linux-gnu"; exit; }
+	;;
+    or32:Linux:*:*)
+	echo ${UNAME_MACHINE}-unknown-linux-gnu
+	exit ;;
+    padre:Linux:*:*)
+	echo sparc-unknown-linux-gnu
+	exit ;;
+    parisc64:Linux:*:* | hppa64:Linux:*:*)
+	echo hppa64-unknown-linux-gnu
+	exit ;;
     parisc:Linux:*:* | hppa:Linux:*:*)
 	# Look for CPU level
 	case `grep '^cpu[^a-z]*:' /proc/cpuinfo 2>/dev/null | cut -d' ' -f2` in
@@ -929,14 +973,17 @@ EOF
 	  *)    echo hppa-unknown-linux-gnu ;;
 	esac
 	exit ;;
-    parisc64:Linux:*:* | hppa64:Linux:*:*)
-	echo hppa64-unknown-linux-gnu
+    ppc64:Linux:*:*)
+	echo powerpc64-unknown-linux-gnu
+	exit ;;
+    ppc:Linux:*:*)
+	echo powerpc-unknown-linux-gnu
 	exit ;;
     s390:Linux:*:* | s390x:Linux:*:*)
 	echo ${UNAME_MACHINE}-ibm-linux
 	exit ;;
     sh64*:Linux:*:*)
-    	echo ${UNAME_MACHINE}-unknown-linux-gnu
+	echo ${UNAME_MACHINE}-unknown-linux-gnu
 	exit ;;
     sh*:Linux:*:*)
 	echo ${UNAME_MACHINE}-unknown-linux-gnu
@@ -944,75 +991,18 @@ EOF
     sparc:Linux:*:* | sparc64:Linux:*:*)
 	echo ${UNAME_MACHINE}-unknown-linux-gnu
 	exit ;;
+    tile*:Linux:*:*)
+	echo ${UNAME_MACHINE}-unknown-linux-gnu
+	exit ;;
     vax:Linux:*:*)
 	echo ${UNAME_MACHINE}-dec-linux-gnu
 	exit ;;
     x86_64:Linux:*:*)
-	echo x86_64-unknown-linux-gnu
+	echo ${UNAME_MACHINE}-unknown-linux-gnu
+	exit ;;
+    xtensa*:Linux:*:*)
+	echo ${UNAME_MACHINE}-unknown-linux-gnu
 	exit ;;
-    i*86:Linux:*:*)
-	# The BFD linker knows what the default object file format is, so
-	# first see if it will tell us. cd to the root directory to prevent
-	# problems with other programs or directories called `ld' in the path.
-	# Set LC_ALL=C to ensure ld outputs messages in English.
-	ld_supported_targets=`cd /; LC_ALL=C ld --help 2>&1 \
-			 | sed -ne '/supported targets:/!d
-				    s/[ 	][ 	]*/ /g
-				    s/.*supported targets: *//
-				    s/ .*//
-				    p'`
-        case "$ld_supported_targets" in
-	  elf32-i386)
-		TENTATIVE="${UNAME_MACHINE}-pc-linux-gnu"
-		;;
-	  a.out-i386-linux)
-		echo "${UNAME_MACHINE}-pc-linux-gnuaout"
-		exit ;;
-	  coff-i386)
-		echo "${UNAME_MACHINE}-pc-linux-gnucoff"
-		exit ;;
-	  "")
-		# Either a pre-BFD a.out linker (linux-gnuoldld) or
-		# one that does not give us useful --help.
-		echo "${UNAME_MACHINE}-pc-linux-gnuoldld"
-		exit ;;
-	esac
-	# Determine whether the default compiler is a.out or elf
-	eval $set_cc_for_build
-	sed 's/^	//' << EOF >$dummy.c
-	#include <features.h>
-	#ifdef __ELF__
-	# ifdef __GLIBC__
-	#  if __GLIBC__ >= 2
-	LIBC=gnu
-	#  else
-	LIBC=gnulibc1
-	#  endif
-	# else
-	LIBC=gnulibc1
-	# endif
-	#else
-	#if defined(__INTEL_COMPILER) || defined(__PGI) || defined(__SUNPRO_C) || defined(__SUNPRO_CC)
-	LIBC=gnu
-	#else
-	LIBC=gnuaout
-	#endif
-	#endif
-	#ifdef __dietlibc__
-	LIBC=dietlibc
-	#endif
-EOF
-	eval "`$CC_FOR_BUILD -E $dummy.c 2>/dev/null | sed -n '
-	    /^LIBC/{
-		s: ::g
-		p
-	    }'`"
-	test x"${LIBC}" != x && {
-		echo "${UNAME_MACHINE}-pc-linux-${LIBC}"
-		exit
-	}
-	test x"${TENTATIVE}" != x && { echo "${TENTATIVE}"; exit; }
-	;;
     i*86:DYNIX/ptx:4*:*)
 	# ptx 4.0 does uname -s correctly, with DYNIX/ptx in there.
 	# earlier versions are messed up and put the nodename in both
@@ -1020,11 +1010,11 @@ EOF
 	echo i386-sequent-sysv4
 	exit ;;
     i*86:UNIX_SV:4.2MP:2.*)
-        # Unixware is an offshoot of SVR4, but it has its own version
-        # number series starting with 2...
-        # I am not positive that other SVR4 systems won't match this,
+	# Unixware is an offshoot of SVR4, but it has its own version
+	# number series starting with 2...
+	# I am not positive that other SVR4 systems won't match this,
 	# I just have to hope.  -- rms.
-        # Use sysv4.2uw... so that sysv4* matches it.
+	# Use sysv4.2uw... so that sysv4* matches it.
 	echo ${UNAME_MACHINE}-pc-sysv4.2uw${UNAME_VERSION}
 	exit ;;
     i*86:OS/2:*:*)
@@ -1041,7 +1031,7 @@ EOF
     i*86:syllable:*:*)
 	echo ${UNAME_MACHINE}-pc-syllable
 	exit ;;
-    i*86:LynxOS:2.*:* | i*86:LynxOS:3.[01]*:* | i*86:LynxOS:4.0*:*)
+    i*86:LynxOS:2.*:* | i*86:LynxOS:3.[01]*:* | i*86:LynxOS:4.[02]*:*)
 	echo i386-unknown-lynxos${UNAME_RELEASE}
 	exit ;;
     i*86:*DOS:*:*)
@@ -1056,7 +1046,7 @@ EOF
 	fi
 	exit ;;
     i*86:*:5:[678]*)
-    	# UnixWare 7.x, OpenUNIX and OpenServer 6.
+	# UnixWare 7.x, OpenUNIX and OpenServer 6.
 	case `/bin/uname -X | grep "^Machine"` in
 	    *486*)	     UNAME_MACHINE=i486 ;;
 	    *Pentium)	     UNAME_MACHINE=i586 ;;
@@ -1084,10 +1074,13 @@ EOF
 	exit ;;
     pc:*:*:*)
 	# Left here for compatibility:
-        # uname -m prints for DJGPP always 'pc', but it prints nothing about
-        # the processor, so we play safe by assuming i386.
-	echo i386-pc-msdosdjgpp
-        exit ;;
+	# uname -m prints for DJGPP always 'pc', but it prints nothing about
+	# the processor, so we play safe by assuming i586.
+	# Note: whatever this is, it MUST be the same as what config.sub
+	# prints for the "djgpp" host, or else GDB configury will decide that
+	# this is a cross-build.
+	echo i586-pc-msdosdjgpp
+	exit ;;
     Intel:Mach:3*:*)
 	echo i386-pc-mach3
 	exit ;;
@@ -1122,8 +1115,18 @@ EOF
 	/bin/uname -p 2>/dev/null | /bin/grep entium >/dev/null \
 	  && { echo i586-ncr-sysv4.3${OS_REL}; exit; } ;;
     3[34]??:*:4.0:* | 3[34]??,*:*:4.0:*)
-        /bin/uname -p 2>/dev/null | grep 86 >/dev/null \
-          && { echo i486-ncr-sysv4; exit; } ;;
+	/bin/uname -p 2>/dev/null | grep 86 >/dev/null \
+	  && { echo i486-ncr-sysv4; exit; } ;;
+    NCR*:*:4.2:* | MPRAS*:*:4.2:*)
+	OS_REL='.3'
+	test -r /etc/.relid \
+	    && OS_REL=.`sed -n 's/[^ ]* [^ ]* \([0-9][0-9]\).*/\1/p' < /etc/.relid`
+	/bin/uname -p 2>/dev/null | grep 86 >/dev/null \
+	    && { echo i486-ncr-sysv4.3${OS_REL}; exit; }
+	/bin/uname -p 2>/dev/null | /bin/grep entium >/dev/null \
+	    && { echo i586-ncr-sysv4.3${OS_REL}; exit; }
+	/bin/uname -p 2>/dev/null | /bin/grep pteron >/dev/null \
+	    && { echo i586-ncr-sysv4.3${OS_REL}; exit; } ;;
     m68*:LynxOS:2.*:* | m68*:LynxOS:3.0*:*)
 	echo m68k-unknown-lynxos${UNAME_RELEASE}
 	exit ;;
@@ -1136,7 +1139,7 @@ EOF
     rs6000:LynxOS:2.*:*)
 	echo rs6000-unknown-lynxos${UNAME_RELEASE}
 	exit ;;
-    PowerPC:LynxOS:2.*:* | PowerPC:LynxOS:3.[01]*:* | PowerPC:LynxOS:4.0*:*)
+    PowerPC:LynxOS:2.*:* | PowerPC:LynxOS:3.[01]*:* | PowerPC:LynxOS:4.[02]*:*)
 	echo powerpc-unknown-lynxos${UNAME_RELEASE}
 	exit ;;
     SM[BE]S:UNIX_SV:*:*)
@@ -1156,10 +1159,10 @@ EOF
 		echo ns32k-sni-sysv
 	fi
 	exit ;;
-    PENTIUM:*:4.0*:*) # Unisys `ClearPath HMP IX 4000' SVR4/MP effort
-                      # says <Richard.M.Bartel@ccMail.Census.GOV>
-        echo i586-unisys-sysv4
-        exit ;;
+    PENTIUM:*:4.0*:*)	# Unisys `ClearPath HMP IX 4000' SVR4/MP effort
+			# says <Richard.M.Bartel@ccMail.Census.GOV>
+	echo i586-unisys-sysv4
+	exit ;;
     *:UNIX_System_V:4*:FTX*)
 	# From Gerald Hewes <hewes@openmarket.com>.
 	# How about differentiating between stratus architectures? -djm
@@ -1185,11 +1188,11 @@ EOF
 	exit ;;
     R[34]000:*System_V*:*:* | R4000:UNIX_SYSV:*:* | R*000:UNIX_SV:*:*)
 	if [ -d /usr/nec ]; then
-	        echo mips-nec-sysv${UNAME_RELEASE}
+		echo mips-nec-sysv${UNAME_RELEASE}
 	else
-	        echo mips-unknown-sysv${UNAME_RELEASE}
+		echo mips-unknown-sysv${UNAME_RELEASE}
 	fi
-        exit ;;
+	exit ;;
     BeBox:BeOS:*:*)	# BeOS running on hardware made by Be, PPC only.
 	echo powerpc-be-beos
 	exit ;;
@@ -1199,6 +1202,9 @@ EOF
     BePC:BeOS:*:*)	# BeOS running on Intel PC compatible.
 	echo i586-pc-beos
 	exit ;;
+    BePC:Haiku:*:*)	# Haiku running on Intel PC compatible.
+	echo i586-pc-haiku
+	exit ;;
     SX-4:SUPER-UX:*:*)
 	echo sx4-nec-superux${UNAME_RELEASE}
 	exit ;;
@@ -1208,6 +1214,15 @@ EOF
     SX-6:SUPER-UX:*:*)
 	echo sx6-nec-superux${UNAME_RELEASE}
 	exit ;;
+    SX-7:SUPER-UX:*:*)
+	echo sx7-nec-superux${UNAME_RELEASE}
+	exit ;;
+    SX-8:SUPER-UX:*:*)
+	echo sx8-nec-superux${UNAME_RELEASE}
+	exit ;;
+    SX-8R:SUPER-UX:*:*)
+	echo sx8r-nec-superux${UNAME_RELEASE}
+	exit ;;
     Power*:Rhapsody:*:*)
 	echo powerpc-apple-rhapsody${UNAME_RELEASE}
 	exit ;;
@@ -1217,6 +1232,16 @@ EOF
     *:Darwin:*:*)
 	UNAME_PROCESSOR=`uname -p` || UNAME_PROCESSOR=unknown
 	case $UNAME_PROCESSOR in
+	    i386)
+		eval $set_cc_for_build
+		if [ "$CC_FOR_BUILD" != 'no_compiler_found' ]; then
+		  if (echo '#ifdef __LP64__'; echo IS_64BIT_ARCH; echo '#endif') | \
+		      (CCOPTS= $CC_FOR_BUILD -E - 2>/dev/null) | \
+		      grep IS_64BIT_ARCH >/dev/null
+		  then
+		      UNAME_PROCESSOR="x86_64"
+		  fi
+		fi ;;
 	    unknown) UNAME_PROCESSOR=powerpc ;;
 	esac
 	echo ${UNAME_PROCESSOR}-apple-darwin${UNAME_RELEASE}
@@ -1232,7 +1257,10 @@ EOF
     *:QNX:*:4*)
 	echo i386-pc-qnx
 	exit ;;
-    NSE-?:NONSTOP_KERNEL:*:*)
+    NEO-?:NONSTOP_KERNEL:*:*)
+	echo neo-tandem-nsk${UNAME_RELEASE}
+	exit ;;
+    NSE-*:NONSTOP_KERNEL:*:*)
 	echo nse-tandem-nsk${UNAME_RELEASE}
 	exit ;;
     NSR-?:NONSTOP_KERNEL:*:*)
@@ -1277,13 +1305,13 @@ EOF
 	echo pdp10-unknown-its
 	exit ;;
     SEI:*:*:SEIUX)
-        echo mips-sei-seiux${UNAME_RELEASE}
+	echo mips-sei-seiux${UNAME_RELEASE}
 	exit ;;
     *:DragonFly:*:*)
 	echo ${UNAME_MACHINE}-unknown-dragonfly`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'`
 	exit ;;
     *:*VMS:*:*)
-    	UNAME_MACHINE=`(uname -p) 2>/dev/null`
+	UNAME_MACHINE=`(uname -p) 2>/dev/null`
 	case "${UNAME_MACHINE}" in
 	    A*) echo alpha-dec-vms ; exit ;;
 	    I*) echo ia64-dec-vms ; exit ;;
@@ -1298,6 +1326,12 @@ EOF
     i*86:rdos:*:*)
 	echo ${UNAME_MACHINE}-pc-rdos
 	exit ;;
+    i*86:AROS:*:*)
+	echo ${UNAME_MACHINE}-pc-aros
+	exit ;;
+    x86_64:VMkernel:*:*)
+	echo ${UNAME_MACHINE}-unknown-esx
+	exit ;;
 esac
 
 #echo '(No uname command or uname output not recognized.)' 1>&2
@@ -1320,11 +1354,11 @@ main ()
 #include <sys/param.h>
   printf ("m68k-sony-newsos%s\n",
 #ifdef NEWSOS4
-          "4"
+	"4"
 #else
-	  ""
+	""
 #endif
-         ); exit (0);
+	); exit (0);
 #endif
 #endif
 
@@ -1458,9 +1492,9 @@ This script, last modified $timestamp, has failed to recognize
 the operating system you are using. It is advised that you
 download the most up to date version of the config scripts from
 
-  http://savannah.gnu.org/cgi-bin/viewcvs/*checkout*/config/config/config.guess
+  http://git.savannah.gnu.org/gitweb/?p=config.git;a=blob_plain;f=config.guess;hb=HEAD
 and
-  http://savannah.gnu.org/cgi-bin/viewcvs/*checkout*/config/config/config.sub
+  http://git.savannah.gnu.org/gitweb/?p=config.git;a=blob_plain;f=config.sub;hb=HEAD
 
 If the version you run ($0) is already up to date, please
 send the following data and any information you think might be

toolkit/crashreporter/google-breakpad/autotools/config.sub

@@ -1,10 +1,10 @@
 #! /bin/sh
 # Configuration validation subroutine script.
 #   Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
-#   2000, 2001, 2002, 2003, 2004, 2005, 2006 Free Software Foundation,
-#   Inc.
+#   2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010,
+#   2011, 2012 Free Software Foundation, Inc.
 
-timestamp='2006-09-20'
+timestamp='2012-06-17'
 
 # This file is (in principle) common to ALL GNU software.
 # The presence of a machine in this file suggests that SOME GNU software
@@ -21,9 +21,7 @@ timestamp='2006-09-20'
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
-# 02110-1301, USA.
+# along with this program; if not, see <http://www.gnu.org/licenses/>.
 #
 # As a special exception to the GNU General Public License, if you
 # distribute this file as part of a program that contains a
@@ -32,13 +30,16 @@ timestamp='2006-09-20'
 
 
 # Please send patches to <config-patches@gnu.org>.  Submit a context
-# diff and a properly formatted ChangeLog entry.
+# diff and a properly formatted GNU ChangeLog entry.
 #
 # Configuration subroutine to validate and canonicalize a configuration type.
 # Supply the specified configuration type as an argument.
 # If it is invalid, we print an error message on stderr and exit with code 1.
 # Otherwise, we print the canonical config type on stdout and succeed.
 
+# You can get the latest version of this script from:
+# http://git.savannah.gnu.org/gitweb/?p=config.git;a=blob_plain;f=config.sub;hb=HEAD
+
 # This file is supposed to be the same for all GNU packages
 # and recognize all the CPU types, system types and aliases
 # that are meaningful with *any* GNU software.
@@ -72,7 +73,8 @@ Report bugs and patches to <config-patches@gnu.org>."
 version="\
 GNU config.sub ($timestamp)
 
-Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005
+Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
+2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012
 Free Software Foundation, Inc.
 
 This is free software; see the source for copying conditions.  There is NO
@@ -120,12 +122,18 @@ esac
 # Here we must recognize all the valid KERNEL-OS combinations.
 maybe_os=`echo $1 | sed 's/^\(.*\)-\([^-]*-[^-]*\)$/\2/'`
 case $maybe_os in
-  nto-qnx* | linux-gnu* | linux-dietlibc | linux-newlib* | linux-uclibc* | \
-  uclinux-uclibc* | uclinux-gnu* | kfreebsd*-gnu* | knetbsd*-gnu* | netbsd*-gnu* | \
+  nto-qnx* | linux-gnu* | linux-android* | linux-dietlibc | linux-newlib* | \
+  linux-uclibc* | uclinux-uclibc* | uclinux-gnu* | kfreebsd*-gnu* | \
+  knetbsd*-gnu* | netbsd*-gnu* | \
+  kopensolaris*-gnu* | \
   storm-chaos* | os2-emx* | rtmk-nova*)
     os=-$maybe_os
     basic_machine=`echo $1 | sed 's/^\(.*\)-\([^-]*-[^-]*\)$/\1/'`
     ;;
+  android-linux)
+    os=-linux-android
+    basic_machine=`echo $1 | sed 's/^\(.*\)-\([^-]*-[^-]*\)$/\1/'`-unknown
+    ;;
   *)
     basic_machine=`echo $1 | sed 's/-[^-]*$//'`
     if [ $basic_machine != $1 ]
@@ -148,10 +156,13 @@ case $os in
 	-convergent* | -ncr* | -news | -32* | -3600* | -3100* | -hitachi* |\
 	-c[123]* | -convex* | -sun | -crds | -omron* | -dg | -ultra | -tti* | \
 	-harris | -dolphin | -highlevel | -gould | -cbm | -ns | -masscomp | \
-	-apple | -axis | -knuth | -cray)
+	-apple | -axis | -knuth | -cray | -microblaze)
 		os=
 		basic_machine=$1
 		;;
+	-bluegene*)
+		os=-cnk
+		;;
 	-sim | -cisco | -oki | -wec | -winbond)
 		os=
 		basic_machine=$1
@@ -166,10 +177,10 @@ case $os in
 		os=-chorusos
 		basic_machine=$1
 		;;
- 	-chorusrdb)
- 		os=-chorusrdb
+	-chorusrdb)
+		os=-chorusrdb
 		basic_machine=$1
- 		;;
+		;;
 	-hiux*)
 		os=-hiuxwe2
 		;;
@@ -214,6 +225,12 @@ case $os in
 	-isc*)
 		basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
 		;;
+	-lynx*178)
+		os=-lynxos178
+		;;
+	-lynx*5)
+		os=-lynxos5
+		;;
 	-lynx*)
 		os=-lynxos
 		;;
@@ -238,24 +255,32 @@ case $basic_machine in
 	# Some are omitted here because they have special meanings below.
 	1750a | 580 \
 	| a29k \
+	| aarch64 | aarch64_be \
 	| alpha | alphaev[4-8] | alphaev56 | alphaev6[78] | alphapca5[67] \
 	| alpha64 | alpha64ev[4-8] | alpha64ev56 | alpha64ev6[78] | alpha64pca5[67] \
 	| am33_2.0 \
 	| arc | arm | arm[bl]e | arme[lb] | armv[2345] | armv[345][lb] | avr | avr32 \
+        | be32 | be64 \
 	| bfin \
 	| c4x | clipper \
 	| d10v | d30v | dlx | dsp16xx \
-	| fr30 | frv \
+	| epiphany \
+	| fido | fr30 | frv \
 	| h8300 | h8500 | hppa | hppa1.[01] | hppa2.0 | hppa2.0[nw] | hppa64 \
+	| hexagon \
 	| i370 | i860 | i960 | ia64 \
 	| ip2k | iq2000 \
+	| le32 | le64 \
+	| lm32 \
 	| m32c | m32r | m32rle | m68000 | m68k | m88k \
-	| maxq | mb | microblaze | mcore \
+	| maxq | mb | microblaze | mcore | mep | metag \
 	| mips | mipsbe | mipseb | mipsel | mipsle \
 	| mips16 \
 	| mips64 | mips64el \
-	| mips64vr | mips64vrel \
+	| mips64octeon | mips64octeonel \
 	| mips64orion | mips64orionel \
+	| mips64r5900 | mips64r5900el \
+	| mips64vr | mips64vrel \
 	| mips64vr4100 | mips64vr4100el \
 	| mips64vr4300 | mips64vr4300el \
 	| mips64vr5000 | mips64vr5000el \
@@ -268,29 +293,42 @@ case $basic_machine in
 	| mipsisa64sr71k | mipsisa64sr71kel \
 	| mipstx39 | mipstx39el \
 	| mn10200 | mn10300 \
+	| moxie \
 	| mt \
 	| msp430 \
+	| nds32 | nds32le | nds32be \
 	| nios | nios2 \
 	| ns16k | ns32k \
+	| open8 \
 	| or32 \
 	| pdp10 | pdp11 | pj | pjl \
-	| powerpc | powerpc64 | powerpc64le | powerpcle | ppcbe \
+	| powerpc | powerpc64 | powerpc64le | powerpcle \
 	| pyramid \
+	| rl78 | rx \
 	| score \
-	| sh | sh[1234] | sh[24]a | sh[23]e | sh[34]eb | sheb | shbe | shle | sh[1234]le | sh3ele \
+	| sh | sh[1234] | sh[24]a | sh[24]aeb | sh[23]e | sh[34]eb | sheb | shbe | shle | sh[1234]le | sh3ele \
 	| sh64 | sh64le \
 	| sparc | sparc64 | sparc64b | sparc64v | sparc86x | sparclet | sparclite \
 	| sparcv8 | sparcv9 | sparcv9b | sparcv9v \
-	| spu | strongarm \
-	| tahoe | thumb | tic4x | tic80 | tron \
-	| v850 | v850e \
+	| spu \
+	| tahoe | tic4x | tic54x | tic55x | tic6x | tic80 | tron \
+	| ubicom32 \
+	| v850 | v850e | v850e1 | v850e2 | v850es | v850e2v3 \
 	| we32k \
-	| x86 | xc16x | xscale | xscalee[bl] | xstormy16 | xtensa \
-	| z8k)
+	| x86 | xc16x | xstormy16 | xtensa \
+	| z8k | z80)
 		basic_machine=$basic_machine-unknown
 		;;
-	m6811 | m68hc11 | m6812 | m68hc12)
-		# Motorola 68HC11/12.
+	c54x)
+		basic_machine=tic54x-unknown
+		;;
+	c55x)
+		basic_machine=tic55x-unknown
+		;;
+	c6x)
+		basic_machine=tic6x-unknown
+		;;
+	m6811 | m68hc11 | m6812 | m68hc12 | m68hcs12x | picochip)
 		basic_machine=$basic_machine-unknown
 		os=-none
 		;;
@@ -300,6 +338,21 @@ case $basic_machine in
 		basic_machine=mt-unknown
 		;;
 
+	strongarm | thumb | xscale)
+		basic_machine=arm-unknown
+		;;
+	xgate)
+		basic_machine=$basic_machine-unknown
+		os=-none
+		;;
+	xscaleeb)
+		basic_machine=armeb-unknown
+		;;
+
+	xscaleel)
+		basic_machine=armel-unknown
+		;;
+
 	# We use `pc' rather than `unknown'
 	# because (1) that's what they normally are, and
 	# (2) the word "unknown" tends to confuse beginning users.
@@ -314,29 +367,36 @@ case $basic_machine in
 	# Recognize the basic CPU types with company name.
 	580-* \
 	| a29k-* \
+	| aarch64-* | aarch64_be-* \
 	| alpha-* | alphaev[4-8]-* | alphaev56-* | alphaev6[78]-* \
 	| alpha64-* | alpha64ev[4-8]-* | alpha64ev56-* | alpha64ev6[78]-* \
 	| alphapca5[67]-* | alpha64pca5[67]-* | arc-* \
 	| arm-*  | armbe-* | armle-* | armeb-* | armv*-* \
 	| avr-* | avr32-* \
+	| be32-* | be64-* \
 	| bfin-* | bs2000-* \
-	| c[123]* | c30-* | [cjt]90-* | c4x-* | c54x-* | c55x-* | c6x-* \
+	| c[123]* | c30-* | [cjt]90-* | c4x-* \
 	| clipper-* | craynv-* | cydra-* \
 	| d10v-* | d30v-* | dlx-* \
 	| elxsi-* \
-	| f30[01]-* | f700-* | fr30-* | frv-* | fx80-* \
+	| f30[01]-* | f700-* | fido-* | fr30-* | frv-* | fx80-* \
 	| h8300-* | h8500-* \
 	| hppa-* | hppa1.[01]-* | hppa2.0-* | hppa2.0[nw]-* | hppa64-* \
+	| hexagon-* \
 	| i*86-* | i860-* | i960-* | ia64-* \
 	| ip2k-* | iq2000-* \
+	| le32-* | le64-* \
+	| lm32-* \
 	| m32c-* | m32r-* | m32rle-* \
 	| m68000-* | m680[012346]0-* | m68360-* | m683?2-* | m68k-* \
-	| m88110-* | m88k-* | maxq-* | mcore-* \
+	| m88110-* | m88k-* | maxq-* | mcore-* | metag-* | microblaze-* \
 	| mips-* | mipsbe-* | mipseb-* | mipsel-* | mipsle-* \
 	| mips16-* \
 	| mips64-* | mips64el-* \
-	| mips64vr-* | mips64vrel-* \
+	| mips64octeon-* | mips64octeonel-* \
 	| mips64orion-* | mips64orionel-* \
+	| mips64r5900-* | mips64r5900el-* \
+	| mips64vr-* | mips64vrel-* \
 	| mips64vr4100-* | mips64vr4100el-* \
 	| mips64vr4300-* | mips64vr4300el-* \
 	| mips64vr5000-* | mips64vr5000el-* \
@@ -351,27 +411,36 @@ case $basic_machine in
 	| mmix-* \
 	| mt-* \
 	| msp430-* \
+	| nds32-* | nds32le-* | nds32be-* \
 	| nios-* | nios2-* \
 	| none-* | np1-* | ns16k-* | ns32k-* \
+	| open8-* \
 	| orion-* \
 	| pdp10-* | pdp11-* | pj-* | pjl-* | pn-* | power-* \
-	| powerpc-* | powerpc64-* | powerpc64le-* | powerpcle-* | ppcbe-* \
+	| powerpc-* | powerpc64-* | powerpc64le-* | powerpcle-* \
 	| pyramid-* \
-	| romp-* | rs6000-* \
-	| sh-* | sh[1234]-* | sh[24]a-* | sh[23]e-* | sh[34]eb-* | sheb-* | shbe-* \
+	| rl78-* | romp-* | rs6000-* | rx-* \
+	| sh-* | sh[1234]-* | sh[24]a-* | sh[24]aeb-* | sh[23]e-* | sh[34]eb-* | sheb-* | shbe-* \
 	| shle-* | sh[1234]le-* | sh3ele-* | sh64-* | sh64le-* \
 	| sparc-* | sparc64-* | sparc64b-* | sparc64v-* | sparc86x-* | sparclet-* \
 	| sparclite-* \
-	| sparcv8-* | sparcv9-* | sparcv9b-* | sparcv9v-* | strongarm-* | sv1-* | sx?-* \
-	| tahoe-* | thumb-* \
+	| sparcv8-* | sparcv9-* | sparcv9b-* | sparcv9v-* | sv1-* | sx?-* \
+	| tahoe-* \
 	| tic30-* | tic4x-* | tic54x-* | tic55x-* | tic6x-* | tic80-* \
+	| tile*-* \
 	| tron-* \
-	| v850-* | v850e-* | vax-* \
+	| ubicom32-* \
+	| v850-* | v850e-* | v850e1-* | v850es-* | v850e2-* | v850e2v3-* \
+	| vax-* \
 	| we32k-* \
-	| x86-* | x86_64-* | xc16x-* | xps100-* | xscale-* | xscalee[bl]-* \
-	| xstormy16-* | xtensa-* \
+	| x86-* | x86_64-* | xc16x-* | xps100-* \
+	| xstormy16-* | xtensa*-* \
 	| ymp-* \
-	| z8k-*)
+	| z8k-* | z80-*)
+		;;
+	# Recognize the basic CPU types without company name, with glob match.
+	xtensa*)
+		basic_machine=$basic_machine-unknown
 		;;
 	# Recognize the various machine names and aliases which stand
 	# for a CPU type and a company and sometimes even an OS.
@@ -389,7 +458,7 @@ case $basic_machine in
 		basic_machine=a29k-amd
 		os=-udi
 		;;
-    	abacus)
+	abacus)
 		basic_machine=abacus-unknown
 		;;
 	adobe68k)
@@ -435,6 +504,10 @@ case $basic_machine in
 		basic_machine=m68k-apollo
 		os=-bsd
 		;;
+	aros)
+		basic_machine=i386-pc
+		os=-aros
+		;;
 	aux)
 		basic_machine=m68k-apple
 		os=-aux
@@ -443,10 +516,35 @@ case $basic_machine in
 		basic_machine=ns32k-sequent
 		os=-dynix
 		;;
+	blackfin)
+		basic_machine=bfin-unknown
+		os=-linux
+		;;
+	blackfin-*)
+		basic_machine=bfin-`echo $basic_machine | sed 's/^[^-]*-//'`
+		os=-linux
+		;;
+	bluegene*)
+		basic_machine=powerpc-ibm
+		os=-cnk
+		;;
+	c54x-*)
+		basic_machine=tic54x-`echo $basic_machine | sed 's/^[^-]*-//'`
+		;;
+	c55x-*)
+		basic_machine=tic55x-`echo $basic_machine | sed 's/^[^-]*-//'`
+		;;
+	c6x-*)
+		basic_machine=tic6x-`echo $basic_machine | sed 's/^[^-]*-//'`
+		;;
 	c90)
 		basic_machine=c90-cray
 		os=-unicos
 		;;
+	cegcc)
+		basic_machine=arm-unknown
+		os=-cegcc
+		;;
 	convex-c1)
 		basic_machine=c1-convex
 		os=-bsd
@@ -475,8 +573,8 @@ case $basic_machine in
 		basic_machine=craynv-cray
 		os=-unicosmp
 		;;
-	cr16c)
-		basic_machine=cr16c-unknown
+	cr16 | cr16-*)
+		basic_machine=cr16-unknown
 		os=-elf
 		;;
 	crds | unos)
@@ -514,6 +612,10 @@ case $basic_machine in
 		basic_machine=m88k-motorola
 		os=-sysv3
 		;;
+	dicos)
+		basic_machine=i686-pc
+		os=-dicos
+		;;
 	djgpp)
 		basic_machine=i586-pc
 		os=-msdosdjgpp
@@ -629,7 +731,6 @@ case $basic_machine in
 	i370-ibm* | ibm*)
 		basic_machine=i370-ibm
 		;;
-# I'm not sure what "Sysv32" means.  Should this be sysv3.2?
 	i*86v32)
 		basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'`
 		os=-sysv32
@@ -668,6 +769,14 @@ case $basic_machine in
 		basic_machine=m68k-isi
 		os=-sysv
 		;;
+	m68knommu)
+		basic_machine=m68k-unknown
+		os=-linux
+		;;
+	m68knommu-*)
+		basic_machine=m68k-`echo $basic_machine | sed 's/^[^-]*-//'`
+		os=-linux
+		;;
 	m88k-omron*)
 		basic_machine=m88k-omron
 		;;
@@ -679,10 +788,17 @@ case $basic_machine in
 		basic_machine=ns32k-utek
 		os=-sysv
 		;;
+	microblaze)
+		basic_machine=microblaze-xilinx
+		;;
 	mingw32)
 		basic_machine=i386-pc
 		os=-mingw32
 		;;
+	mingw32ce)
+		basic_machine=arm-unknown
+		os=-mingw32ce
+		;;
 	miniframe)
 		basic_machine=m68000-convergent
 		;;
@@ -711,10 +827,18 @@ case $basic_machine in
 	ms1-*)
 		basic_machine=`echo $basic_machine | sed -e 's/ms1-/mt-/'`
 		;;
+	msys)
+		basic_machine=i386-pc
+		os=-msys
+		;;
 	mvs)
 		basic_machine=i370-ibm
 		os=-mvs
 		;;
+	nacl)
+		basic_machine=le32-unknown
+		os=-nacl
+		;;
 	ncr3000)
 		basic_machine=i486-ncr
 		os=-sysv4
@@ -779,6 +903,12 @@ case $basic_machine in
 	np1)
 		basic_machine=np1-gould
 		;;
+	neo-tandem)
+		basic_machine=neo-tandem
+		;;
+	nse-tandem)
+		basic_machine=nse-tandem
+		;;
 	nsr-tandem)
 		basic_machine=nsr-tandem
 		;;
@@ -809,6 +939,14 @@ case $basic_machine in
 		basic_machine=i860-intel
 		os=-osf
 		;;
+	parisc)
+		basic_machine=hppa-unknown
+		os=-linux
+		;;
+	parisc-*)
+		basic_machine=hppa-`echo $basic_machine | sed 's/^[^-]*-//'`
+		os=-linux
+		;;
 	pbd)
 		basic_machine=sparc-tti
 		;;
@@ -853,9 +991,10 @@ case $basic_machine in
 		;;
 	power)	basic_machine=power-ibm
 		;;
-	ppc)	basic_machine=powerpc-unknown
+	ppc | ppcbe)	basic_machine=powerpc-unknown
 		;;
-	ppc-*)	basic_machine=powerpc-`echo $basic_machine | sed 's/^[^-]*-//'`
+	ppc-* | ppcbe-*)
+		basic_machine=powerpc-`echo $basic_machine | sed 's/^[^-]*-//'`
 		;;
 	ppcle | powerpclittle | ppc-le | powerpc-little)
 		basic_machine=powerpcle-unknown
@@ -925,6 +1064,9 @@ case $basic_machine in
 		basic_machine=sh-hitachi
 		os=-hms
 		;;
+	sh5el)
+		basic_machine=sh5le-unknown
+		;;
 	sh64)
 		basic_machine=sh64-unknown
 		;;
@@ -946,6 +1088,9 @@ case $basic_machine in
 		basic_machine=i860-stratus
 		os=-sysv4
 		;;
+	strongarm-* | thumb-*)
+		basic_machine=arm-`echo $basic_machine | sed 's/^[^-]*-//'`
+		;;
 	sun2)
 		basic_machine=m68000-sun
 		;;
@@ -1002,17 +1147,9 @@ case $basic_machine in
 		basic_machine=t90-cray
 		os=-unicos
 		;;
-	tic54x | c54x*)
-		basic_machine=tic54x-unknown
-		os=-coff
-		;;
-	tic55x | c55x*)
-		basic_machine=tic55x-unknown
-		os=-coff
-		;;
-	tic6x | c6x*)
-		basic_machine=tic6x-unknown
-		os=-coff
+	tile*)
+		basic_machine=$basic_machine-unknown
+		os=-linux-gnu
 		;;
 	tx39)
 		basic_machine=mipstx39-unknown
@@ -1081,6 +1218,9 @@ case $basic_machine in
 	xps | xps100)
 		basic_machine=xps100-honeywell
 		;;
+	xscale-* | xscalee[bl]-*)
+		basic_machine=`echo $basic_machine | sed 's/^xscale/arm/'`
+		;;
 	ymp)
 		basic_machine=ymp-cray
 		os=-unicos
@@ -1089,6 +1229,10 @@ case $basic_machine in
 		basic_machine=z8k-unknown
 		os=-sim
 		;;
+	z80-*-coff)
+		basic_machine=z80-unknown
+		os=-sim
+		;;
 	none)
 		basic_machine=none-none
 		os=-none
@@ -1127,7 +1271,7 @@ case $basic_machine in
 	we32k)
 		basic_machine=we32k-att
 		;;
-	sh[1234] | sh[24]a | sh[34]eb | sh[1234]le | sh[23]ele)
+	sh[1234] | sh[24]a | sh[24]aeb | sh[34]eb | sh[1234]le | sh[23]ele)
 		basic_machine=sh-unknown
 		;;
 	sparc | sparcv8 | sparcv9 | sparcv9b | sparcv9v)
@@ -1174,9 +1318,12 @@ esac
 if [ x"$os" != x"" ]
 then
 case $os in
-        # First match some system type aliases
-        # that might get confused with valid system types.
+	# First match some system type aliases
+	# that might get confused with valid system types.
 	# -solaris* is a basic system type, with this one exception.
+	-auroraux)
+		os=-auroraux
+		;;
 	-solaris1 | -solaris1.*)
 		os=`echo $os | sed -e 's|solaris1|sunos4|'`
 		;;
@@ -1197,21 +1344,23 @@ case $os in
 	# Each alternative MUST END IN A *, to match a version number.
 	# -sysv* is not here because it comes later, after sysvr4.
 	-gnu* | -bsd* | -mach* | -minix* | -genix* | -ultrix* | -irix* \
-	      | -*vms* | -sco* | -esix* | -isc* | -aix* | -sunos | -sunos[34]*\
-	      | -hpux* | -unos* | -osf* | -luna* | -dgux* | -solaris* | -sym* \
+	      | -*vms* | -sco* | -esix* | -isc* | -aix* | -cnk* | -sunos | -sunos[34]*\
+	      | -hpux* | -unos* | -osf* | -luna* | -dgux* | -auroraux* | -solaris* \
+	      | -sym* | -kopensolaris* \
 	      | -amigaos* | -amigados* | -msdos* | -newsos* | -unicos* | -aof* \
-	      | -aos* \
+	      | -aos* | -aros* \
 	      | -nindy* | -vxsim* | -vxworks* | -ebmon* | -hms* | -mvs* \
 	      | -clix* | -riscos* | -uniplus* | -iris* | -rtu* | -xenix* \
 	      | -hiux* | -386bsd* | -knetbsd* | -mirbsd* | -netbsd* \
-	      | -openbsd* | -solidbsd* \
+	      | -bitrig* | -openbsd* | -solidbsd* \
 	      | -ekkobsd* | -kfreebsd* | -freebsd* | -riscix* | -lynxos* \
 	      | -bosx* | -nextstep* | -cxux* | -aout* | -elf* | -oabi* \
 	      | -ptx* | -coff* | -ecoff* | -winnt* | -domain* | -vsta* \
 	      | -udi* | -eabi* | -lites* | -ieee* | -go32* | -aux* \
-	      | -chorusos* | -chorusrdb* \
-	      | -cygwin* | -pe* | -psos* | -moss* | -proelf* | -rtems* \
-	      | -mingw32* | -linux-gnu* | -linux-newlib* | -linux-uclibc* \
+	      | -chorusos* | -chorusrdb* | -cegcc* \
+	      | -cygwin* | -msys* | -pe* | -psos* | -moss* | -proelf* | -rtems* \
+	      | -mingw32* | -linux-gnu* | -linux-android* \
+	      | -linux-newlib* | -linux-uclibc* \
 	      | -uxpv* | -beos* | -mpeix* | -udk* \
 	      | -interix* | -uwin* | -mks* | -rhapsody* | -darwin* | -opened* \
 	      | -openstep* | -oskit* | -conix* | -pw32* | -nonstopux* \
@@ -1219,7 +1368,7 @@ case $os in
 	      | -os2* | -vos* | -palmos* | -uclinux* | -nucleus* \
 	      | -morphos* | -superux* | -rtmk* | -rtmk-nova* | -windiss* \
 	      | -powermax* | -dnix* | -nx6 | -nx7 | -sei* | -dragonfly* \
-	      | -skyos* | -haiku* | -rdos* | -toppers*)
+	      | -skyos* | -haiku* | -rdos* | -toppers* | -drops* | -es*)
 	# Remember, each alternative MUST END IN *, to match a version number.
 		;;
 	-qnx*)
@@ -1258,7 +1407,7 @@ case $os in
 	-opened*)
 		os=-openedition
 		;;
-        -os400*)
+	-os400*)
 		os=-os400
 		;;
 	-wince*)
@@ -1307,7 +1456,7 @@ case $os in
 	-sinix*)
 		os=-sysv4
 		;;
-        -tpf*)
+	-tpf*)
 		os=-tpf
 		;;
 	-triton*)
@@ -1349,6 +1498,11 @@ case $os in
 	-zvmoe)
 		os=-zvmoe
 		;;
+	-dicos*)
+		os=-dicos
+		;;
+	-nacl*)
+		;;
 	-none)
 		;;
 	*)
@@ -1371,10 +1525,10 @@ else
 # system, and we'll never get to this point.
 
 case $basic_machine in
-        score-*)
+	score-*)
 		os=-elf
 		;;
-        spu-*)
+	spu-*)
 		os=-elf
 		;;
 	*-acorn)
@@ -1386,8 +1540,20 @@ case $basic_machine in
 	arm*-semi)
 		os=-aout
 		;;
-        c4x-* | tic4x-*)
-        	os=-coff
+	c4x-* | tic4x-*)
+		os=-coff
+		;;
+	hexagon-*)
+		os=-elf
+		;;
+	tic54x-*)
+		os=-coff
+		;;
+	tic55x-*)
+		os=-coff
+		;;
+	tic6x-*)
+		os=-coff
 		;;
 	# This must come before the *-dec entry.
 	pdp10-*)
@@ -1407,13 +1573,13 @@ case $basic_machine in
 		;;
 	m68000-sun)
 		os=-sunos3
-		# This also exists in the configure program, but was not the
-		# default.
-		# os=-sunos4
 		;;
 	m68*-cisco)
 		os=-aout
 		;;
+	mep-*)
+		os=-elf
+		;;
 	mips*-cisco)
 		os=-elf
 		;;
@@ -1438,7 +1604,7 @@ case $basic_machine in
 	*-ibm)
 		os=-aix
 		;;
-    	*-knuth)
+	*-knuth)
 		os=-mmixware
 		;;
 	*-wec)
@@ -1543,7 +1709,7 @@ case $basic_machine in
 			-sunos*)
 				vendor=sun
 				;;
-			-aix*)
+			-cnk*|-aix*)
 				vendor=ibm
 				;;
 			-beos*)

toolkit/crashreporter/google-breakpad/configure.ac

@@ -30,24 +30,44 @@
 
 AC_PREREQ(2.57)
 
-AC_INIT(breakpad, 0.1, opensource@google.com)
+AC_INIT(breakpad, 0.1, google-breakpad-dev@googlegroups.com)
 dnl Sanity check: the argument is just a file that should exist.
 AC_CONFIG_SRCDIR(README)
 AC_CONFIG_AUX_DIR(autotools)
+AC_CONFIG_MACRO_DIR([m4])
+AC_CANONICAL_HOST
 
 AM_INIT_AUTOMAKE(subdir-objects tar-ustar 1.11.1)
 AM_CONFIG_HEADER(src/config.h)
 
+AM_PROG_AS
 AC_PROG_CC
+AM_PROG_CC_C_O
 AC_PROG_CPP
 AC_PROG_CXX
-
-AC_PROG_LIBTOOL
-AC_SUBST(LIBTOOL_DEPS)
+AC_PROG_RANLIB
+AM_CONDITIONAL(GCC, test "$GCC" = yes)   # let the Makefile know if we're gcc
 
 AC_HEADER_STDC
 m4_include(m4/ax_pthread.m4)
 AX_PTHREAD
+AC_CHECK_HEADERS([a.out.h])
+
+# Only build Linux client libs when compiling for Linux
+case $host in
+  *-*-linux* | *-android* )
+    LINUX_HOST=true
+    ;;
+esac
+AM_CONDITIONAL(LINUX_HOST, test x$LINUX_HOST = xtrue)
+
+# Only use Android support headers when compiling for Android
+case $host in
+  *-android*)
+    ANDROID_HOST=true
+    ;;
+esac
+AM_CONDITIONAL(ANDROID_HOST, test x$ANDROID_HOST = xtrue)
 
 AC_ARG_ENABLE(m32,
               AS_HELP_STRING([--enable-m32],
@@ -55,7 +75,8 @@ AC_ARG_ENABLE(m32,
                              [(default is no)]),
               [case "${enableval}" in
                  yes)
-		   CFLAGS=$(CFLAGS) -m32
+                   CFLAGS="${CFLAGS} -m32"
+                   CXXFLAGS="${CXXFLAGS} -m32"
                    usem32=true
                    ;;
                  no)
@@ -67,14 +88,45 @@ AC_ARG_ENABLE(m32,
                esac],
               [usem32=false])
 
-AC_CHECK_MEMBER(struct sockaddr.sa_len,
-                [AC_DEFINE([GET_SA_LEN(X)],[(((struct sockaddr*)&(X))->sa_len)],
-                           [actual length of specific struct sockaddr])],
-                [AC_DEFINE([GET_SA_LEN(X)],
-                           [(((struct sockaddr*)&(X))->sa_family == AF_INET  ? sizeof(struct sockaddr_in) : \
-                            ((struct sockaddr*)&(X))->sa_family == AF_INET6 ? sizeof(struct sockaddr_in6) : sizeof(struct sockaddr))],
-                           [actual length of specific struct sockaddr])],
-                [#include <sys/socket.h>])
+AC_ARG_ENABLE(processor,
+              AS_HELP_STRING([--disable-processor],
+                             [Don't build processor library]
+                             [(default is no)]),
+              [case "${enableval}" in
+                 yes)
+                   disable_processor=false
+                   ;;
+                 no)
+                   disable_processor=true
+                   ;;
+                 *)
+                   AC_MSG_ERROR(bad value ${enableval} for --disable-processor)
+                   ;;
+               esac],
+              [disable_processor=false])
+AM_CONDITIONAL(DISABLE_PROCESSOR, test x$disable_processor = xtrue)
+
+AC_ARG_ENABLE(tools,
+              AS_HELP_STRING([--disable-tools],
+                             [Don't build tool binaries]
+                             [(default is no)]),
+              [case "${enableval}" in
+                 yes)
+                   disable_tools=false
+                   ;;
+                 no)
+                   disable_tools=true
+                   ;;
+                 *)
+                   AC_MSG_ERROR(bad value ${enableval} for --disable-tools)
+                   ;;
+               esac],
+              [disable_tools=false])
+AM_CONDITIONAL(DISABLE_TOOLS, test x$disable_tools = xtrue)
+
+if test x$LINUX_HOST = xfalse -a x$disable_processor = xtrue -a x$disable_tools = xtrue; then
+   AC_MSG_ERROR([--disable-processor and --disable-tools were specified, and not building for Linux. Nothing to build!])
+fi
 
 AC_ARG_ENABLE(selftest,
               AS_HELP_STRING([--enable-selftest],

toolkit/crashreporter/google-breakpad/m4/ltoptions.m4

@@ -0,0 +1,368 @@
+# Helper functions for option handling.                    -*- Autoconf -*-
+#
+#   Copyright (C) 2004, 2005, 2007, 2008 Free Software Foundation, Inc.
+#   Written by Gary V. Vaughan, 2004
+#
+# This file is free software; the Free Software Foundation gives
+# unlimited permission to copy and/or distribute it, with or without
+# modifications, as long as this notice is preserved.
+
+# serial 6 ltoptions.m4
+
+# This is to help aclocal find these macros, as it can't see m4_define.
+AC_DEFUN([LTOPTIONS_VERSION], [m4_if([1])])
+
+
+# _LT_MANGLE_OPTION(MACRO-NAME, OPTION-NAME)
+# ------------------------------------------
+m4_define([_LT_MANGLE_OPTION],
+[[_LT_OPTION_]m4_bpatsubst($1__$2, [[^a-zA-Z0-9_]], [_])])
+
+
+# _LT_SET_OPTION(MACRO-NAME, OPTION-NAME)
+# ---------------------------------------
+# Set option OPTION-NAME for macro MACRO-NAME, and if there is a
+# matching handler defined, dispatch to it.  Other OPTION-NAMEs are
+# saved as a flag.
+m4_define([_LT_SET_OPTION],
+[m4_define(_LT_MANGLE_OPTION([$1], [$2]))dnl
+m4_ifdef(_LT_MANGLE_DEFUN([$1], [$2]),
+        _LT_MANGLE_DEFUN([$1], [$2]),
+    [m4_warning([Unknown $1 option `$2'])])[]dnl
+])
+
+
+# _LT_IF_OPTION(MACRO-NAME, OPTION-NAME, IF-SET, [IF-NOT-SET])
+# ------------------------------------------------------------
+# Execute IF-SET if OPTION is set, IF-NOT-SET otherwise.
+m4_define([_LT_IF_OPTION],
+[m4_ifdef(_LT_MANGLE_OPTION([$1], [$2]), [$3], [$4])])
+
+
+# _LT_UNLESS_OPTIONS(MACRO-NAME, OPTION-LIST, IF-NOT-SET)
+# -------------------------------------------------------
+# Execute IF-NOT-SET unless all options in OPTION-LIST for MACRO-NAME
+# are set.
+m4_define([_LT_UNLESS_OPTIONS],
+[m4_foreach([_LT_Option], m4_split(m4_normalize([$2])),
+	    [m4_ifdef(_LT_MANGLE_OPTION([$1], _LT_Option),
+		      [m4_define([$0_found])])])[]dnl
+m4_ifdef([$0_found], [m4_undefine([$0_found])], [$3
+])[]dnl
+])
+
+
+# _LT_SET_OPTIONS(MACRO-NAME, OPTION-LIST)
+# ----------------------------------------
+# OPTION-LIST is a space-separated list of Libtool options associated
+# with MACRO-NAME.  If any OPTION has a matching handler declared with
+# LT_OPTION_DEFINE, dispatch to that macro; otherwise complain about
+# the unknown option and exit.
+m4_defun([_LT_SET_OPTIONS],
+[# Set options
+m4_foreach([_LT_Option], m4_split(m4_normalize([$2])),
+    [_LT_SET_OPTION([$1], _LT_Option)])
+
+m4_if([$1],[LT_INIT],[
+  dnl
+  dnl Simply set some default values (i.e off) if boolean options were not
+  dnl specified:
+  _LT_UNLESS_OPTIONS([LT_INIT], [dlopen], [enable_dlopen=no
+  ])
+  _LT_UNLESS_OPTIONS([LT_INIT], [win32-dll], [enable_win32_dll=no
+  ])
+  dnl
+  dnl If no reference was made to various pairs of opposing options, then
+  dnl we run the default mode handler for the pair.  For example, if neither
+  dnl `shared' nor `disable-shared' was passed, we enable building of shared
+  dnl archives by default:
+  _LT_UNLESS_OPTIONS([LT_INIT], [shared disable-shared], [_LT_ENABLE_SHARED])
+  _LT_UNLESS_OPTIONS([LT_INIT], [static disable-static], [_LT_ENABLE_STATIC])
+  _LT_UNLESS_OPTIONS([LT_INIT], [pic-only no-pic], [_LT_WITH_PIC])
+  _LT_UNLESS_OPTIONS([LT_INIT], [fast-install disable-fast-install],
+  		   [_LT_ENABLE_FAST_INSTALL])
+  ])
+])# _LT_SET_OPTIONS
+
+
+## --------------------------------- ##
+## Macros to handle LT_INIT options. ##
+## --------------------------------- ##
+
+# _LT_MANGLE_DEFUN(MACRO-NAME, OPTION-NAME)
+# -----------------------------------------
+m4_define([_LT_MANGLE_DEFUN],
+[[_LT_OPTION_DEFUN_]m4_bpatsubst(m4_toupper([$1__$2]), [[^A-Z0-9_]], [_])])
+
+
+# LT_OPTION_DEFINE(MACRO-NAME, OPTION-NAME, CODE)
+# -----------------------------------------------
+m4_define([LT_OPTION_DEFINE],
+[m4_define(_LT_MANGLE_DEFUN([$1], [$2]), [$3])[]dnl
+])# LT_OPTION_DEFINE
+
+
+# dlopen
+# ------
+LT_OPTION_DEFINE([LT_INIT], [dlopen], [enable_dlopen=yes
+])
+
+AU_DEFUN([AC_LIBTOOL_DLOPEN],
+[_LT_SET_OPTION([LT_INIT], [dlopen])
+AC_DIAGNOSE([obsolete],
+[$0: Remove this warning and the call to _LT_SET_OPTION when you
+put the `dlopen' option into LT_INIT's first parameter.])
+])
+
+dnl aclocal-1.4 backwards compatibility:
+dnl AC_DEFUN([AC_LIBTOOL_DLOPEN], [])
+
+
+# win32-dll
+# ---------
+# Declare package support for building win32 dll's.
+LT_OPTION_DEFINE([LT_INIT], [win32-dll],
+[enable_win32_dll=yes
+
+case $host in
+*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-cegcc*)
+  AC_CHECK_TOOL(AS, as, false)
+  AC_CHECK_TOOL(DLLTOOL, dlltool, false)
+  AC_CHECK_TOOL(OBJDUMP, objdump, false)
+  ;;
+esac
+
+test -z "$AS" && AS=as
+_LT_DECL([], [AS],      [0], [Assembler program])dnl
+
+test -z "$DLLTOOL" && DLLTOOL=dlltool
+_LT_DECL([], [DLLTOOL], [0], [DLL creation program])dnl
+
+test -z "$OBJDUMP" && OBJDUMP=objdump
+_LT_DECL([], [OBJDUMP], [0], [Object dumper program])dnl
+])# win32-dll
+
+AU_DEFUN([AC_LIBTOOL_WIN32_DLL],
+[AC_REQUIRE([AC_CANONICAL_HOST])dnl
+_LT_SET_OPTION([LT_INIT], [win32-dll])
+AC_DIAGNOSE([obsolete],
+[$0: Remove this warning and the call to _LT_SET_OPTION when you
+put the `win32-dll' option into LT_INIT's first parameter.])
+])
+
+dnl aclocal-1.4 backwards compatibility:
+dnl AC_DEFUN([AC_LIBTOOL_WIN32_DLL], [])
+
+
+# _LT_ENABLE_SHARED([DEFAULT])
+# ----------------------------
+# implement the --enable-shared flag, and supports the `shared' and
+# `disable-shared' LT_INIT options.
+# DEFAULT is either `yes' or `no'.  If omitted, it defaults to `yes'.
+m4_define([_LT_ENABLE_SHARED],
+[m4_define([_LT_ENABLE_SHARED_DEFAULT], [m4_if($1, no, no, yes)])dnl
+AC_ARG_ENABLE([shared],
+    [AS_HELP_STRING([--enable-shared@<:@=PKGS@:>@],
+	[build shared libraries @<:@default=]_LT_ENABLE_SHARED_DEFAULT[@:>@])],
+    [p=${PACKAGE-default}
+    case $enableval in
+    yes) enable_shared=yes ;;
+    no) enable_shared=no ;;
+    *)
+      enable_shared=no
+      # Look at the argument we got.  We use all the common list separators.
+      lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR,"
+      for pkg in $enableval; do
+	IFS="$lt_save_ifs"
+	if test "X$pkg" = "X$p"; then
+	  enable_shared=yes
+	fi
+      done
+      IFS="$lt_save_ifs"
+      ;;
+    esac],
+    [enable_shared=]_LT_ENABLE_SHARED_DEFAULT)
+
+    _LT_DECL([build_libtool_libs], [enable_shared], [0],
+	[Whether or not to build shared libraries])
+])# _LT_ENABLE_SHARED
+
+LT_OPTION_DEFINE([LT_INIT], [shared], [_LT_ENABLE_SHARED([yes])])
+LT_OPTION_DEFINE([LT_INIT], [disable-shared], [_LT_ENABLE_SHARED([no])])
+
+# Old names:
+AC_DEFUN([AC_ENABLE_SHARED],
+[_LT_SET_OPTION([LT_INIT], m4_if([$1], [no], [disable-])[shared])
+])
+
+AC_DEFUN([AC_DISABLE_SHARED],
+[_LT_SET_OPTION([LT_INIT], [disable-shared])
+])
+
+AU_DEFUN([AM_ENABLE_SHARED], [AC_ENABLE_SHARED($@)])
+AU_DEFUN([AM_DISABLE_SHARED], [AC_DISABLE_SHARED($@)])
+
+dnl aclocal-1.4 backwards compatibility:
+dnl AC_DEFUN([AM_ENABLE_SHARED], [])
+dnl AC_DEFUN([AM_DISABLE_SHARED], [])
+
+
+
+# _LT_ENABLE_STATIC([DEFAULT])
+# ----------------------------
+# implement the --enable-static flag, and support the `static' and
+# `disable-static' LT_INIT options.
+# DEFAULT is either `yes' or `no'.  If omitted, it defaults to `yes'.
+m4_define([_LT_ENABLE_STATIC],
+[m4_define([_LT_ENABLE_STATIC_DEFAULT], [m4_if($1, no, no, yes)])dnl
+AC_ARG_ENABLE([static],
+    [AS_HELP_STRING([--enable-static@<:@=PKGS@:>@],
+	[build static libraries @<:@default=]_LT_ENABLE_STATIC_DEFAULT[@:>@])],
+    [p=${PACKAGE-default}
+    case $enableval in
+    yes) enable_static=yes ;;
+    no) enable_static=no ;;
+    *)
+     enable_static=no
+      # Look at the argument we got.  We use all the common list separators.
+      lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR,"
+      for pkg in $enableval; do
+	IFS="$lt_save_ifs"
+	if test "X$pkg" = "X$p"; then
+	  enable_static=yes
+	fi
+      done
+      IFS="$lt_save_ifs"
+      ;;
+    esac],
+    [enable_static=]_LT_ENABLE_STATIC_DEFAULT)
+
+    _LT_DECL([build_old_libs], [enable_static], [0],
+	[Whether or not to build static libraries])
+])# _LT_ENABLE_STATIC
+
+LT_OPTION_DEFINE([LT_INIT], [static], [_LT_ENABLE_STATIC([yes])])
+LT_OPTION_DEFINE([LT_INIT], [disable-static], [_LT_ENABLE_STATIC([no])])
+
+# Old names:
+AC_DEFUN([AC_ENABLE_STATIC],
+[_LT_SET_OPTION([LT_INIT], m4_if([$1], [no], [disable-])[static])
+])
+
+AC_DEFUN([AC_DISABLE_STATIC],
+[_LT_SET_OPTION([LT_INIT], [disable-static])
+])
+
+AU_DEFUN([AM_ENABLE_STATIC], [AC_ENABLE_STATIC($@)])
+AU_DEFUN([AM_DISABLE_STATIC], [AC_DISABLE_STATIC($@)])
+
+dnl aclocal-1.4 backwards compatibility:
+dnl AC_DEFUN([AM_ENABLE_STATIC], [])
+dnl AC_DEFUN([AM_DISABLE_STATIC], [])
+
+
+
+# _LT_ENABLE_FAST_INSTALL([DEFAULT])
+# ----------------------------------
+# implement the --enable-fast-install flag, and support the `fast-install'
+# and `disable-fast-install' LT_INIT options.
+# DEFAULT is either `yes' or `no'.  If omitted, it defaults to `yes'.
+m4_define([_LT_ENABLE_FAST_INSTALL],
+[m4_define([_LT_ENABLE_FAST_INSTALL_DEFAULT], [m4_if($1, no, no, yes)])dnl
+AC_ARG_ENABLE([fast-install],
+    [AS_HELP_STRING([--enable-fast-install@<:@=PKGS@:>@],
+    [optimize for fast installation @<:@default=]_LT_ENABLE_FAST_INSTALL_DEFAULT[@:>@])],
+    [p=${PACKAGE-default}
+    case $enableval in
+    yes) enable_fast_install=yes ;;
+    no) enable_fast_install=no ;;
+    *)
+      enable_fast_install=no
+      # Look at the argument we got.  We use all the common list separators.
+      lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR,"
+      for pkg in $enableval; do
+	IFS="$lt_save_ifs"
+	if test "X$pkg" = "X$p"; then
+	  enable_fast_install=yes
+	fi
+      done
+      IFS="$lt_save_ifs"
+      ;;
+    esac],
+    [enable_fast_install=]_LT_ENABLE_FAST_INSTALL_DEFAULT)
+
+_LT_DECL([fast_install], [enable_fast_install], [0],
+	 [Whether or not to optimize for fast installation])dnl
+])# _LT_ENABLE_FAST_INSTALL
+
+LT_OPTION_DEFINE([LT_INIT], [fast-install], [_LT_ENABLE_FAST_INSTALL([yes])])
+LT_OPTION_DEFINE([LT_INIT], [disable-fast-install], [_LT_ENABLE_FAST_INSTALL([no])])
+
+# Old names:
+AU_DEFUN([AC_ENABLE_FAST_INSTALL],
+[_LT_SET_OPTION([LT_INIT], m4_if([$1], [no], [disable-])[fast-install])
+AC_DIAGNOSE([obsolete],
+[$0: Remove this warning and the call to _LT_SET_OPTION when you put
+the `fast-install' option into LT_INIT's first parameter.])
+])
+
+AU_DEFUN([AC_DISABLE_FAST_INSTALL],
+[_LT_SET_OPTION([LT_INIT], [disable-fast-install])
+AC_DIAGNOSE([obsolete],
+[$0: Remove this warning and the call to _LT_SET_OPTION when you put
+the `disable-fast-install' option into LT_INIT's first parameter.])
+])
+
+dnl aclocal-1.4 backwards compatibility:
+dnl AC_DEFUN([AC_ENABLE_FAST_INSTALL], [])
+dnl AC_DEFUN([AM_DISABLE_FAST_INSTALL], [])
+
+
+# _LT_WITH_PIC([MODE])
+# --------------------
+# implement the --with-pic flag, and support the `pic-only' and `no-pic'
+# LT_INIT options.
+# MODE is either `yes' or `no'.  If omitted, it defaults to `both'.
+m4_define([_LT_WITH_PIC],
+[AC_ARG_WITH([pic],
+    [AS_HELP_STRING([--with-pic],
+	[try to use only PIC/non-PIC objects @<:@default=use both@:>@])],
+    [pic_mode="$withval"],
+    [pic_mode=default])
+
+test -z "$pic_mode" && pic_mode=m4_default([$1], [default])
+
+_LT_DECL([], [pic_mode], [0], [What type of objects to build])dnl
+])# _LT_WITH_PIC
+
+LT_OPTION_DEFINE([LT_INIT], [pic-only], [_LT_WITH_PIC([yes])])
+LT_OPTION_DEFINE([LT_INIT], [no-pic], [_LT_WITH_PIC([no])])
+
+# Old name:
+AU_DEFUN([AC_LIBTOOL_PICMODE],
+[_LT_SET_OPTION([LT_INIT], [pic-only])
+AC_DIAGNOSE([obsolete],
+[$0: Remove this warning and the call to _LT_SET_OPTION when you
+put the `pic-only' option into LT_INIT's first parameter.])
+])
+
+dnl aclocal-1.4 backwards compatibility:
+dnl AC_DEFUN([AC_LIBTOOL_PICMODE], [])
+
+## ----------------- ##
+## LTDL_INIT Options ##
+## ----------------- ##
+
+m4_define([_LTDL_MODE], [])
+LT_OPTION_DEFINE([LTDL_INIT], [nonrecursive],
+		 [m4_define([_LTDL_MODE], [nonrecursive])])
+LT_OPTION_DEFINE([LTDL_INIT], [recursive],
+		 [m4_define([_LTDL_MODE], [recursive])])
+LT_OPTION_DEFINE([LTDL_INIT], [subproject],
+		 [m4_define([_LTDL_MODE], [subproject])])
+
+m4_define([_LTDL_TYPE], [])
+LT_OPTION_DEFINE([LTDL_INIT], [installable],
+		 [m4_define([_LTDL_TYPE], [installable])])
+LT_OPTION_DEFINE([LTDL_INIT], [convenience],
+		 [m4_define([_LTDL_TYPE], [convenience])])

toolkit/crashreporter/google-breakpad/m4/ltsugar.m4

@@ -0,0 +1,123 @@
+# ltsugar.m4 -- libtool m4 base layer.                         -*-Autoconf-*-
+#
+# Copyright (C) 2004, 2005, 2007, 2008 Free Software Foundation, Inc.
+# Written by Gary V. Vaughan, 2004
+#
+# This file is free software; the Free Software Foundation gives
+# unlimited permission to copy and/or distribute it, with or without
+# modifications, as long as this notice is preserved.
+
+# serial 6 ltsugar.m4
+
+# This is to help aclocal find these macros, as it can't see m4_define.
+AC_DEFUN([LTSUGAR_VERSION], [m4_if([0.1])])
+
+
+# lt_join(SEP, ARG1, [ARG2...])
+# -----------------------------
+# Produce ARG1SEPARG2...SEPARGn, omitting [] arguments and their
+# associated separator.
+# Needed until we can rely on m4_join from Autoconf 2.62, since all earlier
+# versions in m4sugar had bugs.
+m4_define([lt_join],
+[m4_if([$#], [1], [],
+       [$#], [2], [[$2]],
+       [m4_if([$2], [], [], [[$2]_])$0([$1], m4_shift(m4_shift($@)))])])
+m4_define([_lt_join],
+[m4_if([$#$2], [2], [],
+       [m4_if([$2], [], [], [[$1$2]])$0([$1], m4_shift(m4_shift($@)))])])
+
+
+# lt_car(LIST)
+# lt_cdr(LIST)
+# ------------
+# Manipulate m4 lists.
+# These macros are necessary as long as will still need to support
+# Autoconf-2.59 which quotes differently.
+m4_define([lt_car], [[$1]])
+m4_define([lt_cdr],
+[m4_if([$#], 0, [m4_fatal([$0: cannot be called without arguments])],
+       [$#], 1, [],
+       [m4_dquote(m4_shift($@))])])
+m4_define([lt_unquote], $1)
+
+
+# lt_append(MACRO-NAME, STRING, [SEPARATOR])
+# ------------------------------------------
+# Redefine MACRO-NAME to hold its former content plus `SEPARATOR'`STRING'.
+# Note that neither SEPARATOR nor STRING are expanded; they are appended
+# to MACRO-NAME as is (leaving the expansion for when MACRO-NAME is invoked).
+# No SEPARATOR is output if MACRO-NAME was previously undefined (different
+# than defined and empty).
+#
+# This macro is needed until we can rely on Autoconf 2.62, since earlier
+# versions of m4sugar mistakenly expanded SEPARATOR but not STRING.
+m4_define([lt_append],
+[m4_define([$1],
+	   m4_ifdef([$1], [m4_defn([$1])[$3]])[$2])])
+
+
+
+# lt_combine(SEP, PREFIX-LIST, INFIX, SUFFIX1, [SUFFIX2...])
+# ----------------------------------------------------------
+# Produce a SEP delimited list of all paired combinations of elements of
+# PREFIX-LIST with SUFFIX1 through SUFFIXn.  Each element of the list
+# has the form PREFIXmINFIXSUFFIXn.
+# Needed until we can rely on m4_combine added in Autoconf 2.62.
+m4_define([lt_combine],
+[m4_if(m4_eval([$# > 3]), [1],
+       [m4_pushdef([_Lt_sep], [m4_define([_Lt_sep], m4_defn([lt_car]))])]]dnl
+[[m4_foreach([_Lt_prefix], [$2],
+	     [m4_foreach([_Lt_suffix],
+		]m4_dquote(m4_dquote(m4_shift(m4_shift(m4_shift($@)))))[,
+	[_Lt_sep([$1])[]m4_defn([_Lt_prefix])[$3]m4_defn([_Lt_suffix])])])])])
+
+
+# lt_if_append_uniq(MACRO-NAME, VARNAME, [SEPARATOR], [UNIQ], [NOT-UNIQ])
+# -----------------------------------------------------------------------
+# Iff MACRO-NAME does not yet contain VARNAME, then append it (delimited
+# by SEPARATOR if supplied) and expand UNIQ, else NOT-UNIQ.
+m4_define([lt_if_append_uniq],
+[m4_ifdef([$1],
+	  [m4_if(m4_index([$3]m4_defn([$1])[$3], [$3$2$3]), [-1],
+		 [lt_append([$1], [$2], [$3])$4],
+		 [$5])],
+	  [lt_append([$1], [$2], [$3])$4])])
+
+
+# lt_dict_add(DICT, KEY, VALUE)
+# -----------------------------
+m4_define([lt_dict_add],
+[m4_define([$1($2)], [$3])])
+
+
+# lt_dict_add_subkey(DICT, KEY, SUBKEY, VALUE)
+# --------------------------------------------
+m4_define([lt_dict_add_subkey],
+[m4_define([$1($2:$3)], [$4])])
+
+
+# lt_dict_fetch(DICT, KEY, [SUBKEY])
+# ----------------------------------
+m4_define([lt_dict_fetch],
+[m4_ifval([$3],
+	m4_ifdef([$1($2:$3)], [m4_defn([$1($2:$3)])]),
+    m4_ifdef([$1($2)], [m4_defn([$1($2)])]))])
+
+
+# lt_if_dict_fetch(DICT, KEY, [SUBKEY], VALUE, IF-TRUE, [IF-FALSE])
+# -----------------------------------------------------------------
+m4_define([lt_if_dict_fetch],
+[m4_if(lt_dict_fetch([$1], [$2], [$3]), [$4],
+	[$5],
+    [$6])])
+
+
+# lt_dict_filter(DICT, [SUBKEY], VALUE, [SEPARATOR], KEY, [...])
+# --------------------------------------------------------------
+m4_define([lt_dict_filter],
+[m4_if([$5], [], [],
+  [lt_join(m4_quote(m4_default([$4], [[, ]])),
+           lt_unquote(m4_split(m4_normalize(m4_foreach(_Lt_key, lt_car([m4_shiftn(4, $@)]),
+		      [lt_if_dict_fetch([$1], _Lt_key, [$2], [$3], [_Lt_key ])])))))])[]dnl
+])

toolkit/crashreporter/google-breakpad/m4/ltversion.m4

@@ -0,0 +1,23 @@
+# ltversion.m4 -- version numbers			-*- Autoconf -*-
+#
+#   Copyright (C) 2004 Free Software Foundation, Inc.
+#   Written by Scott James Remnant, 2004
+#
+# This file is free software; the Free Software Foundation gives
+# unlimited permission to copy and/or distribute it, with or without
+# modifications, as long as this notice is preserved.
+
+# Generated from ltversion.in.
+
+# serial 3017 ltversion.m4
+# This file is part of GNU Libtool
+
+m4_define([LT_PACKAGE_VERSION], [2.2.6b])
+m4_define([LT_PACKAGE_REVISION], [1.3017])
+
+AC_DEFUN([LTVERSION_VERSION],
+[macro_version='2.2.6b'
+macro_revision='1.3017'
+_LT_DECL(, macro_version, 0, [Which release of libtool.m4 was used?])
+_LT_DECL(, macro_revision, 0)
+])

toolkit/crashreporter/google-breakpad/m4/lt~obsolete.m4

@@ -0,0 +1,92 @@
+# lt~obsolete.m4 -- aclocal satisfying obsolete definitions.    -*-Autoconf-*-
+#
+#   Copyright (C) 2004, 2005, 2007 Free Software Foundation, Inc.
+#   Written by Scott James Remnant, 2004.
+#
+# This file is free software; the Free Software Foundation gives
+# unlimited permission to copy and/or distribute it, with or without
+# modifications, as long as this notice is preserved.
+
+# serial 4 lt~obsolete.m4
+
+# These exist entirely to fool aclocal when bootstrapping libtool.
+#
+# In the past libtool.m4 has provided macros via AC_DEFUN (or AU_DEFUN)
+# which have later been changed to m4_define as they aren't part of the
+# exported API, or moved to Autoconf or Automake where they belong.
+#
+# The trouble is, aclocal is a bit thick.  It'll see the old AC_DEFUN
+# in /usr/share/aclocal/libtool.m4 and remember it, then when it sees us
+# using a macro with the same name in our local m4/libtool.m4 it'll
+# pull the old libtool.m4 in (it doesn't see our shiny new m4_define
+# and doesn't know about Autoconf macros at all.)
+#
+# So we provide this file, which has a silly filename so it's always
+# included after everything else.  This provides aclocal with the
+# AC_DEFUNs it wants, but when m4 processes it, it doesn't do anything
+# because those macros already exist, or will be overwritten later.
+# We use AC_DEFUN over AU_DEFUN for compatibility with aclocal-1.6. 
+#
+# Anytime we withdraw an AC_DEFUN or AU_DEFUN, remember to add it here.
+# Yes, that means every name once taken will need to remain here until
+# we give up compatibility with versions before 1.7, at which point
+# we need to keep only those names which we still refer to.
+
+# This is to help aclocal find these macros, as it can't see m4_define.
+AC_DEFUN([LTOBSOLETE_VERSION], [m4_if([1])])
+
+m4_ifndef([AC_LIBTOOL_LINKER_OPTION],	[AC_DEFUN([AC_LIBTOOL_LINKER_OPTION])])
+m4_ifndef([AC_PROG_EGREP],		[AC_DEFUN([AC_PROG_EGREP])])
+m4_ifndef([_LT_AC_PROG_ECHO_BACKSLASH],	[AC_DEFUN([_LT_AC_PROG_ECHO_BACKSLASH])])
+m4_ifndef([_LT_AC_SHELL_INIT],		[AC_DEFUN([_LT_AC_SHELL_INIT])])
+m4_ifndef([_LT_AC_SYS_LIBPATH_AIX],	[AC_DEFUN([_LT_AC_SYS_LIBPATH_AIX])])
+m4_ifndef([_LT_PROG_LTMAIN],		[AC_DEFUN([_LT_PROG_LTMAIN])])
+m4_ifndef([_LT_AC_TAGVAR],		[AC_DEFUN([_LT_AC_TAGVAR])])
+m4_ifndef([AC_LTDL_ENABLE_INSTALL],	[AC_DEFUN([AC_LTDL_ENABLE_INSTALL])])
+m4_ifndef([AC_LTDL_PREOPEN],		[AC_DEFUN([AC_LTDL_PREOPEN])])
+m4_ifndef([_LT_AC_SYS_COMPILER],	[AC_DEFUN([_LT_AC_SYS_COMPILER])])
+m4_ifndef([_LT_AC_LOCK],		[AC_DEFUN([_LT_AC_LOCK])])
+m4_ifndef([AC_LIBTOOL_SYS_OLD_ARCHIVE],	[AC_DEFUN([AC_LIBTOOL_SYS_OLD_ARCHIVE])])
+m4_ifndef([_LT_AC_TRY_DLOPEN_SELF],	[AC_DEFUN([_LT_AC_TRY_DLOPEN_SELF])])
+m4_ifndef([AC_LIBTOOL_PROG_CC_C_O],	[AC_DEFUN([AC_LIBTOOL_PROG_CC_C_O])])
+m4_ifndef([AC_LIBTOOL_SYS_HARD_LINK_LOCKS], [AC_DEFUN([AC_LIBTOOL_SYS_HARD_LINK_LOCKS])])
+m4_ifndef([AC_LIBTOOL_OBJDIR],		[AC_DEFUN([AC_LIBTOOL_OBJDIR])])
+m4_ifndef([AC_LTDL_OBJDIR],		[AC_DEFUN([AC_LTDL_OBJDIR])])
+m4_ifndef([AC_LIBTOOL_PROG_LD_HARDCODE_LIBPATH], [AC_DEFUN([AC_LIBTOOL_PROG_LD_HARDCODE_LIBPATH])])
+m4_ifndef([AC_LIBTOOL_SYS_LIB_STRIP],	[AC_DEFUN([AC_LIBTOOL_SYS_LIB_STRIP])])
+m4_ifndef([AC_PATH_MAGIC],		[AC_DEFUN([AC_PATH_MAGIC])])
+m4_ifndef([AC_PROG_LD_GNU],		[AC_DEFUN([AC_PROG_LD_GNU])])
+m4_ifndef([AC_PROG_LD_RELOAD_FLAG],	[AC_DEFUN([AC_PROG_LD_RELOAD_FLAG])])
+m4_ifndef([AC_DEPLIBS_CHECK_METHOD],	[AC_DEFUN([AC_DEPLIBS_CHECK_METHOD])])
+m4_ifndef([AC_LIBTOOL_PROG_COMPILER_NO_RTTI], [AC_DEFUN([AC_LIBTOOL_PROG_COMPILER_NO_RTTI])])
+m4_ifndef([AC_LIBTOOL_SYS_GLOBAL_SYMBOL_PIPE], [AC_DEFUN([AC_LIBTOOL_SYS_GLOBAL_SYMBOL_PIPE])])
+m4_ifndef([AC_LIBTOOL_PROG_COMPILER_PIC], [AC_DEFUN([AC_LIBTOOL_PROG_COMPILER_PIC])])
+m4_ifndef([AC_LIBTOOL_PROG_LD_SHLIBS],	[AC_DEFUN([AC_LIBTOOL_PROG_LD_SHLIBS])])
+m4_ifndef([AC_LIBTOOL_POSTDEP_PREDEP],	[AC_DEFUN([AC_LIBTOOL_POSTDEP_PREDEP])])
+m4_ifndef([LT_AC_PROG_EGREP],		[AC_DEFUN([LT_AC_PROG_EGREP])])
+m4_ifndef([LT_AC_PROG_SED],		[AC_DEFUN([LT_AC_PROG_SED])])
+m4_ifndef([_LT_CC_BASENAME],		[AC_DEFUN([_LT_CC_BASENAME])])
+m4_ifndef([_LT_COMPILER_BOILERPLATE],	[AC_DEFUN([_LT_COMPILER_BOILERPLATE])])
+m4_ifndef([_LT_LINKER_BOILERPLATE],	[AC_DEFUN([_LT_LINKER_BOILERPLATE])])
+m4_ifndef([_AC_PROG_LIBTOOL],		[AC_DEFUN([_AC_PROG_LIBTOOL])])
+m4_ifndef([AC_LIBTOOL_SETUP],		[AC_DEFUN([AC_LIBTOOL_SETUP])])
+m4_ifndef([_LT_AC_CHECK_DLFCN],		[AC_DEFUN([_LT_AC_CHECK_DLFCN])])
+m4_ifndef([AC_LIBTOOL_SYS_DYNAMIC_LINKER],	[AC_DEFUN([AC_LIBTOOL_SYS_DYNAMIC_LINKER])])
+m4_ifndef([_LT_AC_TAGCONFIG],		[AC_DEFUN([_LT_AC_TAGCONFIG])])
+m4_ifndef([AC_DISABLE_FAST_INSTALL],	[AC_DEFUN([AC_DISABLE_FAST_INSTALL])])
+m4_ifndef([_LT_AC_LANG_CXX],		[AC_DEFUN([_LT_AC_LANG_CXX])])
+m4_ifndef([_LT_AC_LANG_F77],		[AC_DEFUN([_LT_AC_LANG_F77])])
+m4_ifndef([_LT_AC_LANG_GCJ],		[AC_DEFUN([_LT_AC_LANG_GCJ])])
+m4_ifndef([AC_LIBTOOL_RC],		[AC_DEFUN([AC_LIBTOOL_RC])])
+m4_ifndef([AC_LIBTOOL_LANG_C_CONFIG],	[AC_DEFUN([AC_LIBTOOL_LANG_C_CONFIG])])
+m4_ifndef([_LT_AC_LANG_C_CONFIG],	[AC_DEFUN([_LT_AC_LANG_C_CONFIG])])
+m4_ifndef([AC_LIBTOOL_LANG_CXX_CONFIG],	[AC_DEFUN([AC_LIBTOOL_LANG_CXX_CONFIG])])
+m4_ifndef([_LT_AC_LANG_CXX_CONFIG],	[AC_DEFUN([_LT_AC_LANG_CXX_CONFIG])])
+m4_ifndef([AC_LIBTOOL_LANG_F77_CONFIG],	[AC_DEFUN([AC_LIBTOOL_LANG_F77_CONFIG])])
+m4_ifndef([_LT_AC_LANG_F77_CONFIG],	[AC_DEFUN([_LT_AC_LANG_F77_CONFIG])])
+m4_ifndef([AC_LIBTOOL_LANG_GCJ_CONFIG],	[AC_DEFUN([AC_LIBTOOL_LANG_GCJ_CONFIG])])
+m4_ifndef([_LT_AC_LANG_GCJ_CONFIG],	[AC_DEFUN([_LT_AC_LANG_GCJ_CONFIG])])
+m4_ifndef([AC_LIBTOOL_LANG_RC_CONFIG],	[AC_DEFUN([AC_LIBTOOL_LANG_RC_CONFIG])])
+m4_ifndef([_LT_AC_LANG_RC_CONFIG],	[AC_DEFUN([_LT_AC_LANG_RC_CONFIG])])
+m4_ifndef([AC_LIBTOOL_CONFIG],		[AC_DEFUN([AC_LIBTOOL_CONFIG])])
+m4_ifndef([_LT_AC_FILE_LTDLL_C],	[AC_DEFUN([_LT_AC_FILE_LTDLL_C])])

toolkit/crashreporter/google-breakpad/src/client/apple/Framework/BreakpadDefines.h

@@ -0,0 +1,72 @@
+// Copyright (c) 2011, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Keys for configuration file
+#define kReporterMinidumpDirectoryKey "MinidumpDir"
+#define kReporterMinidumpIDKey        "MinidumpID"
+
+// Filename for recording uploaded IDs
+#define kReporterLogFilename          "uploads.log"
+
+// The default subdirectory of the Library to put crash dumps in
+// The subdirectory is
+//  ~/Library/<kDefaultLibrarySubdirectory>/<GoogleBreakpadProduct>
+#define kDefaultLibrarySubdirectory   "Breakpad"
+
+// Specify some special keys to be used in the configuration file that is
+// generated by Breakpad and consumed by the crash_sender.
+#define BREAKPAD_PRODUCT               "BreakpadProduct"
+#define BREAKPAD_PRODUCT_DISPLAY       "BreakpadProductDisplay"
+#define BREAKPAD_VERSION               "BreakpadVersion"
+#define BREAKPAD_VENDOR                "BreakpadVendor"
+#define BREAKPAD_URL                   "BreakpadURL"
+#define BREAKPAD_REPORT_INTERVAL       "BreakpadReportInterval"
+#define BREAKPAD_SKIP_CONFIRM          "BreakpadSkipConfirm"
+#define BREAKPAD_CONFIRM_TIMEOUT       "BreakpadConfirmTimeout"
+#define BREAKPAD_SEND_AND_EXIT         "BreakpadSendAndExit"
+#define BREAKPAD_DUMP_DIRECTORY        "BreakpadMinidumpLocation"
+#define BREAKPAD_INSPECTOR_LOCATION    "BreakpadInspectorLocation"
+#define BREAKPAD_REPORTER_EXE_LOCATION \
+  "BreakpadReporterExeLocation"
+#define BREAKPAD_LOGFILES              "BreakpadLogFiles"
+#define BREAKPAD_LOGFILE_UPLOAD_SIZE   "BreakpadLogFileTailSize"
+#define BREAKPAD_REQUEST_COMMENTS      "BreakpadRequestComments"
+#define BREAKPAD_COMMENTS              "BreakpadComments"
+#define BREAKPAD_REQUEST_EMAIL         "BreakpadRequestEmail"
+#define BREAKPAD_EMAIL                 "BreakpadEmail"
+#define BREAKPAD_SERVER_TYPE           "BreakpadServerType"
+#define BREAKPAD_SERVER_PARAMETER_DICT "BreakpadServerParameters"
+
+// The keys below are NOT user supplied, and are used internally.
+#define BREAKPAD_PROCESS_START_TIME       "BreakpadProcStartTime"
+#define BREAKPAD_PROCESS_UP_TIME          "BreakpadProcessUpTime"
+#define BREAKPAD_PROCESS_CRASH_TIME       "BreakpadProcessCrashTime"
+#define BREAKPAD_LOGFILE_KEY_PREFIX       "BreakpadAppLogFile"
+#define BREAKPAD_SERVER_PARAMETER_PREFIX  "BreakpadServerParameterPrefix_"
+#define BREAKPAD_ON_DEMAND                "BreakpadOnDemand"

toolkit/crashreporter/google-breakpad/src/client/ios/Breakpad.h

@@ -0,0 +1,219 @@
+// Copyright (c) 2011, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Framework to provide a simple C API to crash reporting for
+// applications.  By default, if any machine-level exception (e.g.,
+// EXC_BAD_ACCESS) occurs, it will be handled by the BreakpadRef
+// object as follows:
+//
+// 1. Create a minidump file (see Breakpad for details)
+// 2. Create a config file.
+//
+// These files can then be uploaded to a server.
+
+typedef void *BreakpadRef;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <Foundation/Foundation.h>
+
+#include <client/apple/Framework/BreakpadDefines.h>
+
+// The keys in the dictionary returned by |BreakpadGenerateReport|.
+#define BREAKPAD_OUTPUT_DUMP_FILE   "BreakpadDumpFile"
+#define BREAKPAD_OUTPUT_CONFIG_FILE "BreakpadConfigFile"
+
+// Optional user-defined function to decide if we should handle this crash or
+// forward it along.
+// Return true if you want Breakpad to handle it.
+// Return false if you want Breakpad to skip it
+// The exception handler always returns false, as if SEND_AND_EXIT were false
+// (which means the next exception handler will take the exception)
+typedef bool (*BreakpadFilterCallback)(int exception_type,
+                                       int exception_code,
+                                       mach_port_t crashing_thread,
+                                       void *context);
+
+// Create a new BreakpadRef object and install it as an exception
+// handler.  The |parameters| will typically be the contents of your
+// bundle's Info.plist.
+//
+// You can also specify these additional keys for customizable behavior:
+// Key:                           Value:
+// BREAKPAD_PRODUCT               Product name (e.g., "MyAwesomeProduct")
+//                                This one is used as the key to identify
+//                                the product when uploading. Falls back to
+//                                CFBundleName if not specified.
+//                                REQUIRED
+//
+// BREAKPAD_PRODUCT_DISPLAY       This is the display name, e.g. a pretty
+//                                name for the product when the crash_sender
+//                                pops up UI for the user. Falls back first to
+//                                CFBundleDisplayName and then to
+//                                BREAKPAD_PRODUCT if not specified.
+//
+// BREAKPAD_VERSION               Product version (e.g., 1.2.3), used
+//                                as metadata for crash report. Falls back to
+//                                CFBundleVersion if not specified.
+//                                REQUIRED
+//
+// BREAKPAD_VENDOR                Vendor name, used in UI (e.g. "A report has
+//                                been created that you can send to <vendor>")
+//
+// BREAKPAD_URL                   URL destination for reporting
+//                                REQUIRED
+//
+// BREAKPAD_DUMP_DIRECTORY        The directory to store crash-dumps
+//                                in. By default, we use
+//                                ~/Library/Cache/Breakpad/<BREAKPAD_PRODUCT>
+//                                The path you specify here is tilde-expanded.
+//
+// BREAKPAD_SERVER_TYPE           A parameter that tells Breakpad how to
+//                                rewrite the upload parameters for a specific
+//                                server type.  The currently valid values are
+//                                'socorro' or 'google'.  If you want to add
+//                                other types, see the function in
+//                                crash_report_sender.m that maps parameters to
+//                                URL parameters.  Defaults to 'google'.
+//
+// BREAKPAD_SERVER_PARAMETER_DICT A plist dictionary of static
+//                                parameters that are uploaded to the
+//                                server.  The parameters are sent as
+//                                is to the crash server.  Their
+//                                content isn't added to the minidump
+//                                but pass as URL parameters when
+//                                uploading theminidump to the crash
+//                                server.
+//=============================================================================
+// The BREAKPAD_PRODUCT, BREAKPAD_VERSION and BREAKPAD_URL are
+// required to have non-NULL values.  By default, the BREAKPAD_PRODUCT
+// will be the CFBundleName and the BREAKPAD_VERSION will be the
+// CFBundleVersion when these keys are present in the bundle's
+// Info.plist, which is usually passed in to BreakpadCreate() as an
+// NSDictionary (you could also pass in another dictionary that had
+// the same keys configured).  If the BREAKPAD_PRODUCT or
+// BREAKPAD_VERSION are ultimately undefined, BreakpadCreate() will
+// fail.  You have been warned.
+//
+// If you are running in a debugger, Breakpad will not install, unless the
+// BREAKPAD_IGNORE_DEBUGGER envionment variable is set and/or non-zero.
+//
+//=============================================================================
+// The following are NOT user-supplied but are documented here for
+// completeness.  They are calculated by Breakpad during initialization &
+// crash-dump generation, or entered in by the user.
+//
+// BREAKPAD_PROCESS_START_TIME       The time, in seconds since the Epoch, the
+//                                   process started
+//
+// BREAKPAD_PROCESS_CRASH_TIME       The time, in seconds since the Epoch, the
+//                                   process crashed.
+//
+// BREAKPAD_PROCESS_UP_TIME          The total time in milliseconds the process
+//                                   has been running.  This parameter is not
+//                                   set until the crash-dump-generation phase.
+//
+// BREAKPAD_SERVER_PARAMETER_PREFIX  This prefix is used by Breakpad
+//                                   internally, because Breakpad uses
+//                                   the same dictionary internally to
+//                                   track both its internal
+//                                   configuration parameters and
+//                                   parameters meant to be uploaded
+//                                   to the server.  This string is
+//                                   used internally by Breakpad to
+//                                   prefix user-supplied parameter
+//                                   names so those can be sent to the
+//                                   server without leaking Breakpad's
+//                                   internal values.
+
+// Returns a new BreakpadRef object on success, NULL otherwise.
+BreakpadRef BreakpadCreate(NSDictionary *parameters);
+
+// Uninstall and release the data associated with |ref|.
+void BreakpadRelease(BreakpadRef ref);
+
+// User defined key and value string storage.  Generally this is used
+// to configure Breakpad's internal operation, such as whether the
+// crash_sender should prompt the user, or the filesystem location for
+// the minidump file.  See Breakpad.h for some parameters that can be
+// set.  Anything longer than 255 bytes will be truncated. Note that
+// the string is converted to UTF8 before truncation, so any multibyte
+// character that straddles the 255(256 - 1 for terminator) byte limit
+// will be mangled.
+//
+// A maximum number of 64 key/value pairs are supported.  An assert()
+// will fire if more than this number are set.  Unfortunately, right
+// now, the same dictionary is used for both Breakpad's parameters AND
+// the Upload parameters.
+//
+// TODO (nealsid): Investigate how necessary this is if we don't
+// automatically upload parameters to the server anymore.
+// TODO (nealsid): separate server parameter dictionary from the
+// dictionary used to configure Breakpad, and document limits for each
+// independently.
+void BreakpadSetKeyValue(BreakpadRef ref, NSString *key, NSString *value);
+NSString *BreakpadKeyValue(BreakpadRef ref, NSString *key);
+void BreakpadRemoveKeyValue(BreakpadRef ref, NSString *key);
+
+// You can use this method to specify parameters that will be uploaded
+// to the crash server.  They will be automatically encoded as
+// necessary.  Note that as mentioned above there are limits on both
+// the number of keys and their length.
+void BreakpadAddUploadParameter(BreakpadRef ref, NSString *key,
+                                NSString *value);
+
+// This method will remove a previously-added parameter from the
+// upload parameter set.
+void BreakpadRemoveUploadParameter(BreakpadRef ref, NSString *key);
+
+// Method to handle uploading data to the server
+
+// Returns if there is some report to send to the server.
+bool BreakpadHasCrashReportToUpload(BreakpadRef ref);
+
+// Upload next report to the server.
+void BreakpadUploadNextReport(BreakpadRef ref);
+
+// Upload a file to the server. |data| is the content of the file to sent.
+// |server_parameters| is additional server parameters to send.
+void BreakpadUploadData(BreakpadRef ref, NSData *data, NSString *name,
+                        NSDictionary *server_parameters);
+
+// Generate a breakpad minidump and configuration file in the dump directory.
+// The report will be available for uploading. The paths of the created files
+// are returned in the dictionary. |server_parameters| is additional server
+// parameters to add in the config file.
+NSDictionary *BreakpadGenerateReport(BreakpadRef ref,
+                                     NSDictionary *server_parameters);
+
+#ifdef __cplusplus
+}
+#endif

toolkit/crashreporter/google-breakpad/src/client/ios/Breakpad.mm

@@ -0,0 +1,828 @@
+// Copyright (c) 2011, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#define VERBOSE 0
+
+#if VERBOSE
+  static bool gDebugLog = true;
+#else
+  static bool gDebugLog = false;
+#endif
+
+#define DEBUGLOG if (gDebugLog) fprintf
+#define IGNORE_DEBUGGER "BREAKPAD_IGNORE_DEBUGGER"
+
+#import "common/mac/SimpleStringDictionary.h"
+
+#import "client/mac/crash_generation/ConfigFile.h"
+#import "client/mac/sender/uploader.h"
+#import "client/mac/handler/exception_handler.h"
+#import "client/mac/handler/minidump_generator.h"
+#import "client/ios/Breakpad.h"
+#import "client/ios/handler/ios_exception_minidump_generator.h"
+#import "client/mac/handler/protected_memory_allocator.h"
+
+#import <sys/stat.h>
+#import <sys/sysctl.h>
+
+#import <Foundation/Foundation.h>
+
+using google_breakpad::ConfigFile;
+using google_breakpad::EnsureDirectoryPathExists;
+using google_breakpad::KeyValueEntry;
+using google_breakpad::SimpleStringDictionary;
+using google_breakpad::SimpleStringDictionaryIterator;
+
+//=============================================================================
+// We want any memory allocations which are used by breakpad during the
+// exception handling process (after a crash has happened) to be read-only
+// to prevent them from being smashed before a crash occurs.  Unfortunately
+// we cannot protect against smashes to our exception handling thread's
+// stack.
+//
+// NOTE: Any memory allocations which are not used during the exception
+// handling process may be allocated in the normal ways.
+//
+// The ProtectedMemoryAllocator class provides an Allocate() method which
+// we'll using in conjunction with placement operator new() to control
+// allocation of C++ objects.  Note that we don't use operator delete()
+// but instead call the objects destructor directly:  object->~ClassName();
+//
+ProtectedMemoryAllocator *gMasterAllocator = NULL;
+ProtectedMemoryAllocator *gKeyValueAllocator = NULL;
+ProtectedMemoryAllocator *gBreakpadAllocator = NULL;
+
+// Mutex for thread-safe access to the key/value dictionary used by breakpad.
+// It's a global instead of an instance variable of Breakpad
+// since it can't live in a protected memory area.
+pthread_mutex_t gDictionaryMutex;
+
+//=============================================================================
+// Stack-based object for thread-safe access to a memory-protected region.
+// It's assumed that normally the memory block (allocated by the allocator)
+// is protected (read-only).  Creating a stack-based instance of
+// ProtectedMemoryLocker will unprotect this block after taking the lock.
+// Its destructor will first re-protect the memory then release the lock.
+class ProtectedMemoryLocker {
+public:
+  // allocator may be NULL, in which case no Protect() or Unprotect() calls
+  // will be made, but a lock will still be taken
+  ProtectedMemoryLocker(pthread_mutex_t *mutex,
+                        ProtectedMemoryAllocator *allocator)
+  : mutex_(mutex), allocator_(allocator) {
+    // Lock the mutex
+    assert(pthread_mutex_lock(mutex_) == 0);
+
+    // Unprotect the memory
+    if (allocator_ ) {
+      allocator_->Unprotect();
+    }
+  }
+
+  ~ProtectedMemoryLocker() {
+    // First protect the memory
+    if (allocator_) {
+      allocator_->Protect();
+    }
+
+    // Then unlock the mutex
+    assert(pthread_mutex_unlock(mutex_) == 0);
+  };
+
+private:
+  //  Keep anybody from ever creating one of these things not on the stack.
+  ProtectedMemoryLocker() { }
+  ProtectedMemoryLocker(const ProtectedMemoryLocker&);
+  ProtectedMemoryLocker & operator=(ProtectedMemoryLocker&);
+
+  pthread_mutex_t           *mutex_;
+  ProtectedMemoryAllocator  *allocator_;
+};
+
+//=============================================================================
+class Breakpad {
+ public:
+  // factory method
+  static Breakpad *Create(NSDictionary *parameters) {
+    // Allocate from our special allocation pool
+    Breakpad *breakpad =
+      new (gBreakpadAllocator->Allocate(sizeof(Breakpad)))
+        Breakpad();
+
+    if (!breakpad)
+      return NULL;
+
+    if (!breakpad->Initialize(parameters)) {
+      // Don't use operator delete() here since we allocated from special pool
+      breakpad->~Breakpad();
+      return NULL;
+    }
+
+    return breakpad;
+  }
+
+  ~Breakpad();
+
+  void SetKeyValue(NSString *key, NSString *value);
+  NSString *KeyValue(NSString *key);
+  void RemoveKeyValue(NSString *key);
+  NSString *NextCrashReportToUpload();
+  void UploadNextReport();
+  void UploadData(NSData *data, NSString *name,
+                  NSDictionary *server_parameters);
+  NSDictionary *GenerateReport(NSDictionary *server_parameters);
+
+ private:
+  Breakpad()
+    : handler_(NULL),
+      config_params_(NULL) {}
+
+  bool Initialize(NSDictionary *parameters);
+
+  bool ExtractParameters(NSDictionary *parameters);
+
+  // Dispatches to HandleMinidump()
+  static bool HandleMinidumpCallback(const char *dump_dir,
+                                     const char *minidump_id,
+                                     void *context, bool succeeded);
+
+  bool HandleMinidump(const char *dump_dir,
+                      const char *minidump_id);
+
+  // NSException handler
+  static void UncaughtExceptionHandler(NSException *exception);
+
+  // Handle an uncaught NSException.
+  void HandleUncaughtException(NSException *exception);
+
+  // Since ExceptionHandler (w/o namespace) is defined as typedef in OSX's
+  // MachineExceptions.h, we have to explicitly name the handler.
+  google_breakpad::ExceptionHandler *handler_; // The actual handler (STRONG)
+
+  SimpleStringDictionary  *config_params_; // Create parameters (STRONG)
+
+  ConfigFile config_file_;
+
+  // A static reference to the current Breakpad instance. Used for handling
+  // NSException.
+  static Breakpad *current_breakpad_;
+};
+
+Breakpad *Breakpad::current_breakpad_ = NULL;
+
+#pragma mark -
+#pragma mark Helper functions
+
+//=============================================================================
+// Helper functions
+
+//=============================================================================
+static BOOL IsDebuggerActive() {
+  BOOL result = NO;
+  NSUserDefaults *stdDefaults = [NSUserDefaults standardUserDefaults];
+
+  // We check both defaults and the environment variable here
+
+  BOOL ignoreDebugger = [stdDefaults boolForKey:@IGNORE_DEBUGGER];
+
+  if (!ignoreDebugger) {
+    char *ignoreDebuggerStr = getenv(IGNORE_DEBUGGER);
+    ignoreDebugger =
+        (ignoreDebuggerStr ? strtol(ignoreDebuggerStr, NULL, 10) : 0) != 0;
+  }
+
+  if (!ignoreDebugger) {
+    pid_t pid = getpid();
+    int mib[4] = {CTL_KERN, KERN_PROC, KERN_PROC_PID, pid};
+    int mibSize = sizeof(mib) / sizeof(int);
+    size_t actualSize;
+
+    if (sysctl(mib, mibSize, NULL, &actualSize, NULL, 0) == 0) {
+      struct kinfo_proc *info = (struct kinfo_proc *)malloc(actualSize);
+
+      if (info) {
+        // This comes from looking at the Darwin xnu Kernel
+        if (sysctl(mib, mibSize, info, &actualSize, NULL, 0) == 0)
+          result = (info->kp_proc.p_flag & P_TRACED) ? YES : NO;
+
+        free(info);
+      }
+    }
+  }
+
+  return result;
+}
+
+//=============================================================================
+bool Breakpad::HandleMinidumpCallback(const char *dump_dir,
+                                      const char *minidump_id,
+                                      void *context, bool succeeded) {
+  Breakpad *breakpad = (Breakpad *)context;
+
+  // If our context is damaged or something, just return false to indicate that
+  // the handler should continue without us.
+  if (!breakpad || !succeeded)
+    return false;
+
+  return breakpad->HandleMinidump(dump_dir, minidump_id);
+}
+
+//=============================================================================
+void Breakpad::UncaughtExceptionHandler(NSException *exception) {
+  NSSetUncaughtExceptionHandler(NULL);
+  if (current_breakpad_) {
+    current_breakpad_->HandleUncaughtException(exception);
+  }
+}
+
+//=============================================================================
+#pragma mark -
+
+//=============================================================================
+bool Breakpad::Initialize(NSDictionary *parameters) {
+  // Initialize
+  current_breakpad_ = this;
+  config_params_ = NULL;
+  handler_ = NULL;
+
+  // Gather any user specified parameters
+  if (!ExtractParameters(parameters)) {
+    return false;
+  }
+
+  // Check for debugger
+  if (IsDebuggerActive()) {
+    DEBUGLOG(stderr, "Debugger is active:  Not installing handler\n");
+    return true;
+  }
+
+  // Create the handler (allocating it in our special protected pool)
+  handler_ =
+      new (gBreakpadAllocator->Allocate(
+          sizeof(google_breakpad::ExceptionHandler)))
+          google_breakpad::ExceptionHandler(
+              config_params_->GetValueForKey(BREAKPAD_DUMP_DIRECTORY),
+              0, &HandleMinidumpCallback, this, true, 0);
+  NSSetUncaughtExceptionHandler(&Breakpad::UncaughtExceptionHandler);
+  return true;
+}
+
+//=============================================================================
+Breakpad::~Breakpad() {
+  NSSetUncaughtExceptionHandler(NULL);
+  current_breakpad_ = NULL;
+  // Note that we don't use operator delete() on these pointers,
+  // since they were allocated by ProtectedMemoryAllocator objects.
+  //
+  if (config_params_) {
+    config_params_->~SimpleStringDictionary();
+  }
+
+  if (handler_)
+    handler_->~ExceptionHandler();
+}
+
+//=============================================================================
+bool Breakpad::ExtractParameters(NSDictionary *parameters) {
+  NSString *serverType = [parameters objectForKey:@BREAKPAD_SERVER_TYPE];
+  NSString *display = [parameters objectForKey:@BREAKPAD_PRODUCT_DISPLAY];
+  NSString *product = [parameters objectForKey:@BREAKPAD_PRODUCT];
+  NSString *version = [parameters objectForKey:@BREAKPAD_VERSION];
+  NSString *urlStr = [parameters objectForKey:@BREAKPAD_URL];
+  NSString *vendor =
+      [parameters objectForKey:@BREAKPAD_VENDOR];
+  NSString *dumpSubdirectory =
+      [parameters objectForKey:@BREAKPAD_DUMP_DIRECTORY];
+
+  NSDictionary *serverParameters =
+      [parameters objectForKey:@BREAKPAD_SERVER_PARAMETER_DICT];
+
+  if (!product)
+    product = [parameters objectForKey:@"CFBundleName"];
+
+  if (!display) {
+    display = [parameters objectForKey:@"CFBundleDisplayName"];
+    if (!display) {
+      display = product;
+    }
+  }
+
+  if (!version)
+    version = [parameters objectForKey:@"CFBundleVersion"];
+
+  if (!vendor) {
+    vendor = @"Vendor not specified";
+  }
+
+  if (!dumpSubdirectory) {
+    NSString *cachePath =
+        [NSSearchPathForDirectoriesInDomains(NSCachesDirectory,
+                                             NSUserDomainMask,
+                                             YES)
+            objectAtIndex:0];
+    dumpSubdirectory =
+        [cachePath stringByAppendingPathComponent:@kDefaultLibrarySubdirectory];
+
+    EnsureDirectoryPathExists(dumpSubdirectory);
+  }
+
+  // The product, version, and URL are required values.
+  if (![product length]) {
+    DEBUGLOG(stderr, "Missing required product key.\n");
+    return false;
+  }
+
+  if (![version length]) {
+    DEBUGLOG(stderr, "Missing required version key.\n");
+    return false;
+  }
+
+  if (![urlStr length]) {
+    DEBUGLOG(stderr, "Missing required URL key.\n");
+    return false;
+  }
+
+  config_params_ =
+      new (gKeyValueAllocator->Allocate(sizeof(SimpleStringDictionary)) )
+        SimpleStringDictionary();
+
+  SimpleStringDictionary &dictionary = *config_params_;
+
+  dictionary.SetKeyValue(BREAKPAD_SERVER_TYPE,     [serverType UTF8String]);
+  dictionary.SetKeyValue(BREAKPAD_PRODUCT_DISPLAY, [display UTF8String]);
+  dictionary.SetKeyValue(BREAKPAD_PRODUCT,         [product UTF8String]);
+  dictionary.SetKeyValue(BREAKPAD_VERSION,         [version UTF8String]);
+  dictionary.SetKeyValue(BREAKPAD_URL,             [urlStr UTF8String]);
+  dictionary.SetKeyValue(BREAKPAD_VENDOR,          [vendor UTF8String]);
+  dictionary.SetKeyValue(BREAKPAD_DUMP_DIRECTORY,
+                         [dumpSubdirectory UTF8String]);
+
+  struct timeval tv;
+  gettimeofday(&tv, NULL);
+  char timeStartedString[32];
+  sprintf(timeStartedString, "%zd", tv.tv_sec);
+  dictionary.SetKeyValue(BREAKPAD_PROCESS_START_TIME, timeStartedString);
+
+  if (serverParameters) {
+    // For each key-value pair, call BreakpadAddUploadParameter()
+    NSEnumerator *keyEnumerator = [serverParameters keyEnumerator];
+    NSString *aParameter;
+    while ((aParameter = [keyEnumerator nextObject])) {
+      BreakpadAddUploadParameter(this, aParameter,
+				 [serverParameters objectForKey:aParameter]);
+    }
+  }
+  return true;
+}
+
+//=============================================================================
+void Breakpad::SetKeyValue(NSString *key, NSString *value) {
+  // We allow nil values. This is the same as removing the keyvalue.
+  if (!config_params_ || !key)
+    return;
+
+  config_params_->SetKeyValue([key UTF8String], [value UTF8String]);
+}
+
+//=============================================================================
+NSString *Breakpad::KeyValue(NSString *key) {
+  if (!config_params_ || !key)
+    return nil;
+
+  const char *value = config_params_->GetValueForKey([key UTF8String]);
+  return value ? [NSString stringWithUTF8String:value] : nil;
+}
+
+//=============================================================================
+void Breakpad::RemoveKeyValue(NSString *key) {
+  if (!config_params_ || !key) return;
+
+  config_params_->RemoveKey([key UTF8String]);
+}
+
+//=============================================================================
+NSString *Breakpad::NextCrashReportToUpload() {
+  NSString *directory = KeyValue(@BREAKPAD_DUMP_DIRECTORY);
+  if (!directory)
+    return nil;
+  NSArray *dirContents = [[NSFileManager defaultManager]
+      contentsOfDirectoryAtPath:directory error:nil];
+  NSArray *configs = [dirContents filteredArrayUsingPredicate:[NSPredicate
+      predicateWithFormat:@"self BEGINSWITH 'Config-'"]];
+  NSString *config = [configs lastObject];
+  if (!config)
+    return nil;
+  return [NSString stringWithFormat:@"%@/%@", directory, config];
+}
+
+//=============================================================================
+void Breakpad::UploadNextReport() {
+  NSString *configFile = NextCrashReportToUpload();
+  if (configFile) {
+    Uploader *uploader = [[[Uploader alloc]
+        initWithConfigFile:[configFile UTF8String]] autorelease];
+    if (uploader)
+      [uploader report];
+  }
+}
+
+//=============================================================================
+void Breakpad::UploadData(NSData *data, NSString *name,
+                          NSDictionary *server_parameters) {
+  NSMutableDictionary *config = [NSMutableDictionary dictionary];
+
+  SimpleStringDictionaryIterator it(*config_params_);
+  while (const KeyValueEntry *next = it.Next()) {
+    [config setValue:[NSString stringWithUTF8String:next->GetValue()]
+              forKey:[NSString stringWithUTF8String:next->GetKey()]];
+  }
+
+  Uploader *uploader =
+      [[[Uploader alloc] initWithConfig:config] autorelease];
+  for (NSString *key in server_parameters) {
+    [uploader addServerParameter:[server_parameters objectForKey:key]
+                          forKey:key];
+  }
+  [uploader uploadData:data name:name];
+}
+
+//=============================================================================
+NSDictionary *Breakpad::GenerateReport(NSDictionary *server_parameters) {
+  NSString *dumpDirAsNSString = KeyValue(@BREAKPAD_DUMP_DIRECTORY);
+  if (!dumpDirAsNSString)
+    return nil;
+  const char *dumpDir = [dumpDirAsNSString UTF8String];
+
+  google_breakpad::MinidumpGenerator generator(mach_task_self(),
+                                               MACH_PORT_NULL);
+  std::string dumpId;
+  std::string dumpFilename = generator.UniqueNameInDirectory(dumpDir, &dumpId);
+  bool success = generator.Write(dumpFilename.c_str());
+  if (!success)
+    return nil;
+
+  SimpleStringDictionary params = *config_params_;
+  for (NSString *key in server_parameters) {
+    params.SetKeyValue([key UTF8String],
+                       [[server_parameters objectForKey:key] UTF8String]);
+  }
+  ConfigFile config_file;
+  config_file.WriteFile(dumpDir, &params, dumpDir, dumpId.c_str());
+
+  // Handle results.
+  NSMutableDictionary *result = [NSMutableDictionary dictionary];
+  NSString *dumpFullPath = [dumpDirAsNSString stringByAppendingPathComponent:
+      [NSString stringWithUTF8String:dumpFilename.c_str()]];
+  [result setValue:dumpFullPath
+            forKey:@BREAKPAD_OUTPUT_DUMP_FILE];
+  [result setValue:[NSString stringWithUTF8String:config_file.GetFilePath()]
+            forKey:@BREAKPAD_OUTPUT_CONFIG_FILE];
+  return result;
+}
+
+//=============================================================================
+bool Breakpad::HandleMinidump(const char *dump_dir,
+                              const char *minidump_id) {
+  DEBUGLOG(stderr, "Breakpad: a minidump has been created.\n");
+
+  config_file_.WriteFile(dump_dir,
+                         config_params_,
+                         dump_dir,
+                         minidump_id);
+
+  // Return true here to indicate that we've processed things as much as we
+  // want.
+  return true;
+}
+
+//=============================================================================
+void Breakpad::HandleUncaughtException(NSException *exception) {
+  // Generate the minidump.
+  google_breakpad::IosExceptionMinidumpGenerator generator(exception);
+  const char *minidump_path =
+      config_params_->GetValueForKey(BREAKPAD_DUMP_DIRECTORY);
+  std::string minidump_id;
+  std::string minidump_filename = generator.UniqueNameInDirectory(minidump_path,
+                                                                  &minidump_id);
+  generator.Write(minidump_filename.c_str());
+
+  // Copy the config params and our custom parameter. This is necessary for 2
+  // reasons:
+  // 1- config_params_ is protected.
+  // 2- If the application crash while trying to handle this exception, a usual
+  //    report will be generated. This report must not contain these special
+  //    keys.
+  SimpleStringDictionary params = *config_params_;
+  params.SetKeyValue(BREAKPAD_SERVER_PARAMETER_PREFIX "type", "exception");
+  params.SetKeyValue(BREAKPAD_SERVER_PARAMETER_PREFIX "exceptionName",
+                     [[exception name] UTF8String]);
+  params.SetKeyValue(BREAKPAD_SERVER_PARAMETER_PREFIX "exceptionReason",
+                     [[exception reason] UTF8String]);
+
+  // And finally write the config file.
+  ConfigFile config_file;
+  config_file.WriteFile(minidump_path,
+                        &params,
+                        minidump_path,
+                        minidump_id.c_str());
+}
+
+//=============================================================================
+
+#pragma mark -
+#pragma mark Public API
+
+//=============================================================================
+BreakpadRef BreakpadCreate(NSDictionary *parameters) {
+  try {
+    // This is confusing.  Our two main allocators for breakpad memory are:
+    //    - gKeyValueAllocator for the key/value memory
+    //    - gBreakpadAllocator for the Breakpad, ExceptionHandler, and other
+    //      breakpad allocations which are accessed at exception handling time.
+    //
+    // But in order to avoid these two allocators themselves from being smashed,
+    // we'll protect them as well by allocating them with gMasterAllocator.
+    //
+    // gMasterAllocator itself will NOT be protected, but this doesn't matter,
+    // since once it does its allocations and locks the memory, smashes to
+    // itself don't affect anything we care about.
+    gMasterAllocator =
+        new ProtectedMemoryAllocator(sizeof(ProtectedMemoryAllocator) * 2);
+
+    gKeyValueAllocator =
+        new (gMasterAllocator->Allocate(sizeof(ProtectedMemoryAllocator)))
+            ProtectedMemoryAllocator(sizeof(SimpleStringDictionary));
+
+    // Create a mutex for use in accessing the SimpleStringDictionary
+    int mutexResult = pthread_mutex_init(&gDictionaryMutex, NULL);
+    if (mutexResult == 0) {
+
+      // With the current compiler, gBreakpadAllocator is allocating 1444 bytes.
+      // Let's round up to the nearest page size.
+      //
+      int breakpad_pool_size = 4096;
+
+      /*
+       sizeof(Breakpad)
+       + sizeof(google_breakpad::ExceptionHandler)
+       + sizeof( STUFF ALLOCATED INSIDE ExceptionHandler )
+       */
+
+      gBreakpadAllocator =
+          new (gMasterAllocator->Allocate(sizeof(ProtectedMemoryAllocator)))
+              ProtectedMemoryAllocator(breakpad_pool_size);
+
+      // Stack-based autorelease pool for Breakpad::Create() obj-c code.
+      NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
+      Breakpad *breakpad = Breakpad::Create(parameters);
+
+      if (breakpad) {
+        // Make read-only to protect against memory smashers
+        gMasterAllocator->Protect();
+        gKeyValueAllocator->Protect();
+        gBreakpadAllocator->Protect();
+        // Can uncomment this line to figure out how much space was actually
+        // allocated using this allocator
+        //     printf("gBreakpadAllocator allocated size = %d\n",
+        //         gBreakpadAllocator->GetAllocatedSize() );
+        [pool release];
+        return (BreakpadRef)breakpad;
+      }
+
+      [pool release];
+    }
+  } catch(...) {    // don't let exceptions leave this C API
+    fprintf(stderr, "BreakpadCreate() : error\n");
+  }
+
+  if (gKeyValueAllocator) {
+    gKeyValueAllocator->~ProtectedMemoryAllocator();
+    gKeyValueAllocator = NULL;
+  }
+
+  if (gBreakpadAllocator) {
+    gBreakpadAllocator->~ProtectedMemoryAllocator();
+    gBreakpadAllocator = NULL;
+  }
+
+  delete gMasterAllocator;
+  gMasterAllocator = NULL;
+
+  return NULL;
+}
+
+//=============================================================================
+void BreakpadRelease(BreakpadRef ref) {
+  try {
+    Breakpad *breakpad = (Breakpad *)ref;
+
+    if (gMasterAllocator) {
+      gMasterAllocator->Unprotect();
+      gKeyValueAllocator->Unprotect();
+      gBreakpadAllocator->Unprotect();
+
+      breakpad->~Breakpad();
+
+      // Unfortunately, it's not possible to deallocate this stuff
+      // because the exception handling thread is still finishing up
+      // asynchronously at this point...  OK, it could be done with
+      // locks, etc.  But since BreakpadRelease() should usually only
+      // be called right before the process exits, it's not worth
+      // deallocating this stuff.
+#if 0
+      gKeyValueAllocator->~ProtectedMemoryAllocator();
+      gBreakpadAllocator->~ProtectedMemoryAllocator();
+      delete gMasterAllocator;
+
+      gMasterAllocator = NULL;
+      gKeyValueAllocator = NULL;
+      gBreakpadAllocator = NULL;
+#endif
+
+      pthread_mutex_destroy(&gDictionaryMutex);
+    }
+  } catch(...) {    // don't let exceptions leave this C API
+    fprintf(stderr, "BreakpadRelease() : error\n");
+  }
+}
+
+//=============================================================================
+void BreakpadSetKeyValue(BreakpadRef ref, NSString *key, NSString *value) {
+  try {
+    // Not called at exception time
+    Breakpad *breakpad = (Breakpad *)ref;
+
+    if (breakpad && key && gKeyValueAllocator) {
+      ProtectedMemoryLocker locker(&gDictionaryMutex, gKeyValueAllocator);
+
+      breakpad->SetKeyValue(key, value);
+    }
+  } catch(...) {    // don't let exceptions leave this C API
+    fprintf(stderr, "BreakpadSetKeyValue() : error\n");
+  }
+}
+
+void BreakpadAddUploadParameter(BreakpadRef ref,
+                                NSString *key,
+                                NSString *value) {
+  // The only difference, internally, between an upload parameter and
+  // a key value one that is set with BreakpadSetKeyValue is that we
+  // prepend the keyname with a special prefix.  This informs the
+  // crash sender that the parameter should be sent along with the
+  // POST of the crash dump upload.
+  try {
+    Breakpad *breakpad = (Breakpad *)ref;
+
+    if (breakpad && key && gKeyValueAllocator) {
+      ProtectedMemoryLocker locker(&gDictionaryMutex, gKeyValueAllocator);
+
+      NSString *prefixedKey = [@BREAKPAD_SERVER_PARAMETER_PREFIX
+				stringByAppendingString:key];
+      breakpad->SetKeyValue(prefixedKey, value);
+    }
+  } catch(...) {    // don't let exceptions leave this C API
+    fprintf(stderr, "BreakpadSetKeyValue() : error\n");
+  }
+}
+
+void BreakpadRemoveUploadParameter(BreakpadRef ref,
+                                   NSString *key) {
+  try {
+    // Not called at exception time
+    Breakpad *breakpad = (Breakpad *)ref;
+
+    if (breakpad && key && gKeyValueAllocator) {
+      ProtectedMemoryLocker locker(&gDictionaryMutex, gKeyValueAllocator);
+
+      NSString *prefixedKey = [NSString stringWithFormat:@"%@%@",
+                                        @BREAKPAD_SERVER_PARAMETER_PREFIX, key];
+      breakpad->RemoveKeyValue(prefixedKey);
+    }
+  } catch(...) {    // don't let exceptions leave this C API
+    fprintf(stderr, "BreakpadRemoveKeyValue() : error\n");
+  }
+}
+//=============================================================================
+NSString *BreakpadKeyValue(BreakpadRef ref, NSString *key) {
+  NSString *value = nil;
+
+  try {
+    // Not called at exception time
+    Breakpad *breakpad = (Breakpad *)ref;
+
+    if (!breakpad || !key || !gKeyValueAllocator)
+      return nil;
+
+    ProtectedMemoryLocker locker(&gDictionaryMutex, gKeyValueAllocator);
+
+    value = breakpad->KeyValue(key);
+  } catch(...) {    // don't let exceptions leave this C API
+    fprintf(stderr, "BreakpadKeyValue() : error\n");
+  }
+
+  return value;
+}
+
+//=============================================================================
+void BreakpadRemoveKeyValue(BreakpadRef ref, NSString *key) {
+  try {
+    // Not called at exception time
+    Breakpad *breakpad = (Breakpad *)ref;
+
+    if (breakpad && key && gKeyValueAllocator) {
+      ProtectedMemoryLocker locker(&gDictionaryMutex, gKeyValueAllocator);
+
+      breakpad->RemoveKeyValue(key);
+    }
+  } catch(...) {    // don't let exceptions leave this C API
+    fprintf(stderr, "BreakpadRemoveKeyValue() : error\n");
+  }
+}
+
+//=============================================================================
+bool BreakpadHasCrashReportToUpload(BreakpadRef ref) {
+  try {
+    // Not called at exception time
+    Breakpad *breakpad = (Breakpad *)ref;
+
+    if (breakpad) {
+       return breakpad->NextCrashReportToUpload() != 0;
+    }
+  } catch(...) {    // don't let exceptions leave this C API
+    fprintf(stderr, "BreakpadHasCrashReportToUpload() : error\n");
+  }
+  return false;
+}
+
+//=============================================================================
+void BreakpadUploadNextReport(BreakpadRef ref) {
+  try {
+    // Not called at exception time
+    Breakpad *breakpad = (Breakpad *)ref;
+
+    if (breakpad) {
+       breakpad->UploadNextReport();
+    }
+  } catch(...) {    // don't let exceptions leave this C API
+    fprintf(stderr, "BreakpadUploadNextReport() : error\n");
+  }
+}
+
+//=============================================================================
+void BreakpadUploadData(BreakpadRef ref, NSData *data, NSString *name,
+                        NSDictionary *server_parameters) {
+  try {
+    // Not called at exception time
+    Breakpad *breakpad = (Breakpad *)ref;
+
+    if (breakpad) {
+      breakpad->UploadData(data, name, server_parameters);
+    }
+  } catch(...) {    // don't let exceptions leave this C API
+    fprintf(stderr, "BreakpadUploadData() : error\n");
+  }
+}
+
+//=============================================================================
+NSDictionary *BreakpadGenerateReport(BreakpadRef ref,
+                                     NSDictionary *server_parameters) {
+  try {
+    // Not called at exception time
+    Breakpad *breakpad = (Breakpad *)ref;
+
+    if (breakpad) {
+      return breakpad->GenerateReport(server_parameters);
+    } else {
+      return nil;
+    }
+  } catch(...) {    // don't let exceptions leave this C API
+    fprintf(stderr, "BreakpadGenerateReport() : error\n");
+    return nil;
+  }
+}

toolkit/crashreporter/google-breakpad/src/client/ios/Breakpad.xcodeproj/project.pbxproj

@@ -0,0 +1,566 @@
+// !$*UTF8*$!
+{
+	archiveVersion = 1;
+	classes = {
+	};
+	objectVersion = 46;
+	objects = {
+
+/* Begin PBXBuildFile section */
+		16BFA67014E195E9009704F8 /* ios_exception_minidump_generator.h in Headers */ = {isa = PBXBuildFile; fileRef = 16BFA66E14E195E9009704F8 /* ios_exception_minidump_generator.h */; };
+		16BFA67214E1965A009704F8 /* ios_exception_minidump_generator.mm in Sources */ = {isa = PBXBuildFile; fileRef = 16BFA67114E1965A009704F8 /* ios_exception_minidump_generator.mm */; };
+		16C7CCCB147D4A4300776EAD /* BreakpadDefines.h in Headers */ = {isa = PBXBuildFile; fileRef = 16C7C968147D4A4200776EAD /* BreakpadDefines.h */; };
+		16C7CCCC147D4A4300776EAD /* Breakpad.h in Headers */ = {isa = PBXBuildFile; fileRef = 16C7C96A147D4A4200776EAD /* Breakpad.h */; };
+		16C7CCCD147D4A4300776EAD /* Breakpad.mm in Sources */ = {isa = PBXBuildFile; fileRef = 16C7C96B147D4A4200776EAD /* Breakpad.mm */; };
+		16C7CDE8147D4A4300776EAD /* ConfigFile.h in Headers */ = {isa = PBXBuildFile; fileRef = 16C7CB9E147D4A4300776EAD /* ConfigFile.h */; };
+		16C7CDE9147D4A4300776EAD /* ConfigFile.mm in Sources */ = {isa = PBXBuildFile; fileRef = 16C7CB9F147D4A4300776EAD /* ConfigFile.mm */; };
+		16C7CDF5147D4A4300776EAD /* breakpad_nlist_64.cc in Sources */ = {isa = PBXBuildFile; fileRef = 16C7CBAD147D4A4300776EAD /* breakpad_nlist_64.cc */; };
+		16C7CDF6147D4A4300776EAD /* breakpad_nlist_64.h in Headers */ = {isa = PBXBuildFile; fileRef = 16C7CBAE147D4A4300776EAD /* breakpad_nlist_64.h */; };
+		16C7CDF7147D4A4300776EAD /* dynamic_images.cc in Sources */ = {isa = PBXBuildFile; fileRef = 16C7CBAF147D4A4300776EAD /* dynamic_images.cc */; };
+		16C7CDF8147D4A4300776EAD /* dynamic_images.h in Headers */ = {isa = PBXBuildFile; fileRef = 16C7CBB0147D4A4300776EAD /* dynamic_images.h */; };
+		16C7CDF9147D4A4300776EAD /* exception_handler.cc in Sources */ = {isa = PBXBuildFile; fileRef = 16C7CBB1147D4A4300776EAD /* exception_handler.cc */; };
+		16C7CDFA147D4A4300776EAD /* exception_handler.h in Headers */ = {isa = PBXBuildFile; fileRef = 16C7CBB2147D4A4300776EAD /* exception_handler.h */; };
+		16C7CDFC147D4A4300776EAD /* minidump_generator.cc in Sources */ = {isa = PBXBuildFile; fileRef = 16C7CBB4147D4A4300776EAD /* minidump_generator.cc */; };
+		16C7CDFD147D4A4300776EAD /* minidump_generator.h in Headers */ = {isa = PBXBuildFile; fileRef = 16C7CBB5147D4A4300776EAD /* minidump_generator.h */; };
+		16C7CDFE147D4A4300776EAD /* protected_memory_allocator.cc in Sources */ = {isa = PBXBuildFile; fileRef = 16C7CBBC147D4A4300776EAD /* protected_memory_allocator.cc */; };
+		16C7CDFF147D4A4300776EAD /* protected_memory_allocator.h in Headers */ = {isa = PBXBuildFile; fileRef = 16C7CBBD147D4A4300776EAD /* protected_memory_allocator.h */; };
+		16C7CE08147D4A4300776EAD /* uploader.h in Headers */ = {isa = PBXBuildFile; fileRef = 16C7CBEA147D4A4300776EAD /* uploader.h */; };
+		16C7CE09147D4A4300776EAD /* uploader.mm in Sources */ = {isa = PBXBuildFile; fileRef = 16C7CBEB147D4A4300776EAD /* uploader.mm */; };
+		16C7CE18147D4A4300776EAD /* minidump_file_writer-inl.h in Headers */ = {isa = PBXBuildFile; fileRef = 16C7CC04147D4A4300776EAD /* minidump_file_writer-inl.h */; };
+		16C7CE19147D4A4300776EAD /* minidump_file_writer.cc in Sources */ = {isa = PBXBuildFile; fileRef = 16C7CC05147D4A4300776EAD /* minidump_file_writer.cc */; };
+		16C7CE1A147D4A4300776EAD /* minidump_file_writer.h in Headers */ = {isa = PBXBuildFile; fileRef = 16C7CC06147D4A4300776EAD /* minidump_file_writer.h */; };
+		16C7CE1B147D4A4300776EAD /* minidump_file_writer_unittest.cc in Sources */ = {isa = PBXBuildFile; fileRef = 16C7CC07147D4A4300776EAD /* minidump_file_writer_unittest.cc */; };
+		16C7CE40147D4A4300776EAD /* convert_UTF.c in Sources */ = {isa = PBXBuildFile; fileRef = 16C7CC4A147D4A4300776EAD /* convert_UTF.c */; };
+		16C7CE41147D4A4300776EAD /* convert_UTF.h in Headers */ = {isa = PBXBuildFile; fileRef = 16C7CC4B147D4A4300776EAD /* convert_UTF.h */; };
+		16C7CE78147D4A4300776EAD /* GTMLogger.h in Headers */ = {isa = PBXBuildFile; fileRef = 16C7CC88147D4A4300776EAD /* GTMLogger.h */; };
+		16C7CE79147D4A4300776EAD /* GTMLogger.m in Sources */ = {isa = PBXBuildFile; fileRef = 16C7CC89147D4A4300776EAD /* GTMLogger.m */; };
+		16C7CE7A147D4A4300776EAD /* HTTPMultipartUpload.h in Headers */ = {isa = PBXBuildFile; fileRef = 16C7CC8A147D4A4300776EAD /* HTTPMultipartUpload.h */; };
+		16C7CE7B147D4A4300776EAD /* HTTPMultipartUpload.m in Sources */ = {isa = PBXBuildFile; fileRef = 16C7CC8B147D4A4300776EAD /* HTTPMultipartUpload.m */; };
+		16C7CE7E147D4A4300776EAD /* SimpleStringDictionary.h in Headers */ = {isa = PBXBuildFile; fileRef = 16C7CC8E147D4A4300776EAD /* SimpleStringDictionary.h */; };
+		16C7CE7F147D4A4300776EAD /* SimpleStringDictionary.mm in Sources */ = {isa = PBXBuildFile; fileRef = 16C7CC8F147D4A4300776EAD /* SimpleStringDictionary.mm */; };
+		16C7CE83147D4A4300776EAD /* file_id.cc in Sources */ = {isa = PBXBuildFile; fileRef = 16C7CC93147D4A4300776EAD /* file_id.cc */; };
+		16C7CE84147D4A4300776EAD /* file_id.h in Headers */ = {isa = PBXBuildFile; fileRef = 16C7CC94147D4A4300776EAD /* file_id.h */; };
+		16C7CE85147D4A4300776EAD /* macho_id.cc in Sources */ = {isa = PBXBuildFile; fileRef = 16C7CC95147D4A4300776EAD /* macho_id.cc */; };
+		16C7CE86147D4A4300776EAD /* macho_id.h in Headers */ = {isa = PBXBuildFile; fileRef = 16C7CC96147D4A4300776EAD /* macho_id.h */; };
+		16C7CE8A147D4A4300776EAD /* macho_utilities.cc in Sources */ = {isa = PBXBuildFile; fileRef = 16C7CC9A147D4A4300776EAD /* macho_utilities.cc */; };
+		16C7CE8B147D4A4300776EAD /* macho_utilities.h in Headers */ = {isa = PBXBuildFile; fileRef = 16C7CC9B147D4A4300776EAD /* macho_utilities.h */; };
+		16C7CE8C147D4A4300776EAD /* macho_walker.cc in Sources */ = {isa = PBXBuildFile; fileRef = 16C7CC9C147D4A4300776EAD /* macho_walker.cc */; };
+		16C7CE8D147D4A4300776EAD /* macho_walker.h in Headers */ = {isa = PBXBuildFile; fileRef = 16C7CC9D147D4A4300776EAD /* macho_walker.h */; };
+		16C7CE8F147D4A4300776EAD /* string_utilities.cc in Sources */ = {isa = PBXBuildFile; fileRef = 16C7CC9F147D4A4300776EAD /* string_utilities.cc */; };
+		16C7CE90147D4A4300776EAD /* string_utilities.h in Headers */ = {isa = PBXBuildFile; fileRef = 16C7CCA0147D4A4300776EAD /* string_utilities.h */; };
+		16C7CE93147D4A4300776EAD /* md5.cc in Sources */ = {isa = PBXBuildFile; fileRef = 16C7CCA4147D4A4300776EAD /* md5.cc */; };
+		16C7CE94147D4A4300776EAD /* md5.h in Headers */ = {isa = PBXBuildFile; fileRef = 16C7CCA5147D4A4300776EAD /* md5.h */; };
+		16C7CEA7147D4A4300776EAD /* string_conversion.cc in Sources */ = {isa = PBXBuildFile; fileRef = 16C7CCB9147D4A4300776EAD /* string_conversion.cc */; };
+		16C7CEA8147D4A4300776EAD /* string_conversion.h in Headers */ = {isa = PBXBuildFile; fileRef = 16C7CCBA147D4A4300776EAD /* string_conversion.h */; };
+		16C92FAD150DF8330053D7BA /* BreakpadController.h in Headers */ = {isa = PBXBuildFile; fileRef = 16C92FAB150DF8330053D7BA /* BreakpadController.h */; };
+		16C92FAE150DF8330053D7BA /* BreakpadController.mm in Sources */ = {isa = PBXBuildFile; fileRef = 16C92FAC150DF8330053D7BA /* BreakpadController.mm */; };
+		AA747D9F0F9514B9006C5449 /* Breakpad_Prefix.pch in Headers */ = {isa = PBXBuildFile; fileRef = AA747D9E0F9514B9006C5449 /* Breakpad_Prefix.pch */; };
+		AACBBE4A0F95108600F1A2B1 /* Foundation.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = AACBBE490F95108600F1A2B1 /* Foundation.framework */; };
+/* End PBXBuildFile section */
+
+/* Begin PBXFileReference section */
+		16BFA66E14E195E9009704F8 /* ios_exception_minidump_generator.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ios_exception_minidump_generator.h; sourceTree = "<group>"; };
+		16BFA67114E1965A009704F8 /* ios_exception_minidump_generator.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = ios_exception_minidump_generator.mm; sourceTree = "<group>"; };
+		16C7C968147D4A4200776EAD /* BreakpadDefines.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = BreakpadDefines.h; sourceTree = "<group>"; };
+		16C7C96A147D4A4200776EAD /* Breakpad.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Breakpad.h; sourceTree = "<group>"; };
+		16C7C96B147D4A4200776EAD /* Breakpad.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = Breakpad.mm; sourceTree = "<group>"; };
+		16C7CB9E147D4A4300776EAD /* ConfigFile.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ConfigFile.h; sourceTree = "<group>"; };
+		16C7CB9F147D4A4300776EAD /* ConfigFile.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = ConfigFile.mm; sourceTree = "<group>"; };
+		16C7CBAD147D4A4300776EAD /* breakpad_nlist_64.cc */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = breakpad_nlist_64.cc; sourceTree = "<group>"; };
+		16C7CBAE147D4A4300776EAD /* breakpad_nlist_64.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = breakpad_nlist_64.h; sourceTree = "<group>"; };
+		16C7CBAF147D4A4300776EAD /* dynamic_images.cc */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = dynamic_images.cc; sourceTree = "<group>"; };
+		16C7CBB0147D4A4300776EAD /* dynamic_images.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = dynamic_images.h; sourceTree = "<group>"; };
+		16C7CBB1147D4A4300776EAD /* exception_handler.cc */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = exception_handler.cc; sourceTree = "<group>"; };
+		16C7CBB2147D4A4300776EAD /* exception_handler.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = exception_handler.h; sourceTree = "<group>"; };
+		16C7CBB4147D4A4300776EAD /* minidump_generator.cc */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = minidump_generator.cc; sourceTree = "<group>"; };
+		16C7CBB5147D4A4300776EAD /* minidump_generator.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = minidump_generator.h; sourceTree = "<group>"; };
+		16C7CBBC147D4A4300776EAD /* protected_memory_allocator.cc */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = protected_memory_allocator.cc; sourceTree = "<group>"; };
+		16C7CBBD147D4A4300776EAD /* protected_memory_allocator.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = protected_memory_allocator.h; sourceTree = "<group>"; };
+		16C7CBEA147D4A4300776EAD /* uploader.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = uploader.h; sourceTree = "<group>"; };
+		16C7CBEB147D4A4300776EAD /* uploader.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = uploader.mm; sourceTree = "<group>"; };
+		16C7CC04147D4A4300776EAD /* minidump_file_writer-inl.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "minidump_file_writer-inl.h"; sourceTree = "<group>"; };
+		16C7CC05147D4A4300776EAD /* minidump_file_writer.cc */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = minidump_file_writer.cc; sourceTree = "<group>"; };
+		16C7CC06147D4A4300776EAD /* minidump_file_writer.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = minidump_file_writer.h; sourceTree = "<group>"; };
+		16C7CC07147D4A4300776EAD /* minidump_file_writer_unittest.cc */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = minidump_file_writer_unittest.cc; sourceTree = "<group>"; };
+		16C7CC4A147D4A4300776EAD /* convert_UTF.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = convert_UTF.c; sourceTree = "<group>"; };
+		16C7CC4B147D4A4300776EAD /* convert_UTF.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = convert_UTF.h; sourceTree = "<group>"; };
+		16C7CC88147D4A4300776EAD /* GTMLogger.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = GTMLogger.h; sourceTree = "<group>"; };
+		16C7CC89147D4A4300776EAD /* GTMLogger.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = GTMLogger.m; sourceTree = "<group>"; };
+		16C7CC8A147D4A4300776EAD /* HTTPMultipartUpload.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = HTTPMultipartUpload.h; sourceTree = "<group>"; };
+		16C7CC8B147D4A4300776EAD /* HTTPMultipartUpload.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = HTTPMultipartUpload.m; sourceTree = "<group>"; };
+		16C7CC8E147D4A4300776EAD /* SimpleStringDictionary.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = SimpleStringDictionary.h; sourceTree = "<group>"; };
+		16C7CC8F147D4A4300776EAD /* SimpleStringDictionary.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = SimpleStringDictionary.mm; sourceTree = "<group>"; };
+		16C7CC93147D4A4300776EAD /* file_id.cc */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = file_id.cc; sourceTree = "<group>"; };
+		16C7CC94147D4A4300776EAD /* file_id.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = file_id.h; sourceTree = "<group>"; };
+		16C7CC95147D4A4300776EAD /* macho_id.cc */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = macho_id.cc; sourceTree = "<group>"; };
+		16C7CC96147D4A4300776EAD /* macho_id.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = macho_id.h; sourceTree = "<group>"; };
+		16C7CC9A147D4A4300776EAD /* macho_utilities.cc */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = macho_utilities.cc; sourceTree = "<group>"; };
+		16C7CC9B147D4A4300776EAD /* macho_utilities.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = macho_utilities.h; sourceTree = "<group>"; };
+		16C7CC9C147D4A4300776EAD /* macho_walker.cc */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = macho_walker.cc; sourceTree = "<group>"; };
+		16C7CC9D147D4A4300776EAD /* macho_walker.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = macho_walker.h; sourceTree = "<group>"; };
+		16C7CC9F147D4A4300776EAD /* string_utilities.cc */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = string_utilities.cc; sourceTree = "<group>"; };
+		16C7CCA0147D4A4300776EAD /* string_utilities.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = string_utilities.h; sourceTree = "<group>"; };
+		16C7CCA4147D4A4300776EAD /* md5.cc */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = md5.cc; sourceTree = "<group>"; };
+		16C7CCA5147D4A4300776EAD /* md5.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = md5.h; sourceTree = "<group>"; };
+		16C7CCB9147D4A4300776EAD /* string_conversion.cc */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = string_conversion.cc; sourceTree = "<group>"; };
+		16C7CCBA147D4A4300776EAD /* string_conversion.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = string_conversion.h; sourceTree = "<group>"; };
+		16C92FAB150DF8330053D7BA /* BreakpadController.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = BreakpadController.h; sourceTree = "<group>"; };
+		16C92FAC150DF8330053D7BA /* BreakpadController.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = BreakpadController.mm; sourceTree = "<group>"; };
+		AA747D9E0F9514B9006C5449 /* Breakpad_Prefix.pch */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Breakpad_Prefix.pch; sourceTree = SOURCE_ROOT; };
+		AACBBE490F95108600F1A2B1 /* Foundation.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = Foundation.framework; path = System/Library/Frameworks/Foundation.framework; sourceTree = SDKROOT; };
+		D2AAC07E0554694100DB518D /* libBreakpad.a */ = {isa = PBXFileReference; explicitFileType = archive.ar; includeInIndex = 0; path = libBreakpad.a; sourceTree = BUILT_PRODUCTS_DIR; };
+/* End PBXFileReference section */
+
+/* Begin PBXFrameworksBuildPhase section */
+		D2AAC07C0554694100DB518D /* Frameworks */ = {
+			isa = PBXFrameworksBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				AACBBE4A0F95108600F1A2B1 /* Foundation.framework in Frameworks */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXFrameworksBuildPhase section */
+
+/* Begin PBXGroup section */
+		034768DFFF38A50411DB9C8B /* Products */ = {
+			isa = PBXGroup;
+			children = (
+				D2AAC07E0554694100DB518D /* libBreakpad.a */,
+			);
+			name = Products;
+			sourceTree = "<group>";
+		};
+		0867D691FE84028FC02AAC07 /* Breakpad */ = {
+			isa = PBXGroup;
+			children = (
+				08FB77AEFE84172EC02AAC07 /* Classes */,
+				32C88DFF0371C24200C91783 /* Other Sources */,
+				0867D69AFE84028FC02AAC07 /* Frameworks */,
+				034768DFFF38A50411DB9C8B /* Products */,
+			);
+			name = Breakpad;
+			sourceTree = "<group>";
+		};
+		0867D69AFE84028FC02AAC07 /* Frameworks */ = {
+			isa = PBXGroup;
+			children = (
+				AACBBE490F95108600F1A2B1 /* Foundation.framework */,
+			);
+			name = Frameworks;
+			sourceTree = "<group>";
+		};
+		08FB77AEFE84172EC02AAC07 /* Classes */ = {
+			isa = PBXGroup;
+			children = (
+				16C7C965147D4A4200776EAD /* client */,
+				16C7CC47147D4A4300776EAD /* common */,
+			);
+			name = Classes;
+			sourceTree = "<group>";
+		};
+		16BFA66A14E195E9009704F8 /* handler */ = {
+			isa = PBXGroup;
+			children = (
+				16BFA67114E1965A009704F8 /* ios_exception_minidump_generator.mm */,
+				16BFA66E14E195E9009704F8 /* ios_exception_minidump_generator.h */,
+			);
+			path = handler;
+			sourceTree = "<group>";
+		};
+		16C7C965147D4A4200776EAD /* client */ = {
+			isa = PBXGroup;
+			children = (
+				16C7C966147D4A4200776EAD /* apple */,
+				16C7C969147D4A4200776EAD /* ios */,
+				16C7C99E147D4A4200776EAD /* mac */,
+				16C7CC04147D4A4300776EAD /* minidump_file_writer-inl.h */,
+				16C7CC05147D4A4300776EAD /* minidump_file_writer.cc */,
+				16C7CC06147D4A4300776EAD /* minidump_file_writer.h */,
+				16C7CC07147D4A4300776EAD /* minidump_file_writer_unittest.cc */,
+			);
+			name = client;
+			path = ..;
+			sourceTree = SOURCE_ROOT;
+		};
+		16C7C966147D4A4200776EAD /* apple */ = {
+			isa = PBXGroup;
+			children = (
+				16C7C967147D4A4200776EAD /* Framework */,
+			);
+			path = apple;
+			sourceTree = "<group>";
+		};
+		16C7C967147D4A4200776EAD /* Framework */ = {
+			isa = PBXGroup;
+			children = (
+				16C7C968147D4A4200776EAD /* BreakpadDefines.h */,
+			);
+			path = Framework;
+			sourceTree = "<group>";
+		};
+		16C7C969147D4A4200776EAD /* ios */ = {
+			isa = PBXGroup;
+			children = (
+				16C92FAB150DF8330053D7BA /* BreakpadController.h */,
+				16C92FAC150DF8330053D7BA /* BreakpadController.mm */,
+				16BFA66A14E195E9009704F8 /* handler */,
+				16C7C96A147D4A4200776EAD /* Breakpad.h */,
+				16C7C96B147D4A4200776EAD /* Breakpad.mm */,
+			);
+			path = ios;
+			sourceTree = "<group>";
+		};
+		16C7C99E147D4A4200776EAD /* mac */ = {
+			isa = PBXGroup;
+			children = (
+				16C7CB9D147D4A4300776EAD /* crash_generation */,
+				16C7CBAA147D4A4300776EAD /* handler */,
+				16C7CBC8147D4A4300776EAD /* sender */,
+			);
+			path = mac;
+			sourceTree = "<group>";
+		};
+		16C7CB9D147D4A4300776EAD /* crash_generation */ = {
+			isa = PBXGroup;
+			children = (
+				16C7CB9E147D4A4300776EAD /* ConfigFile.h */,
+				16C7CB9F147D4A4300776EAD /* ConfigFile.mm */,
+			);
+			path = crash_generation;
+			sourceTree = "<group>";
+		};
+		16C7CBAA147D4A4300776EAD /* handler */ = {
+			isa = PBXGroup;
+			children = (
+				16C7CBAD147D4A4300776EAD /* breakpad_nlist_64.cc */,
+				16C7CBAE147D4A4300776EAD /* breakpad_nlist_64.h */,
+				16C7CBAF147D4A4300776EAD /* dynamic_images.cc */,
+				16C7CBB0147D4A4300776EAD /* dynamic_images.h */,
+				16C7CBB1147D4A4300776EAD /* exception_handler.cc */,
+				16C7CBB2147D4A4300776EAD /* exception_handler.h */,
+				16C7CBB4147D4A4300776EAD /* minidump_generator.cc */,
+				16C7CBB5147D4A4300776EAD /* minidump_generator.h */,
+				16C7CBBC147D4A4300776EAD /* protected_memory_allocator.cc */,
+				16C7CBBD147D4A4300776EAD /* protected_memory_allocator.h */,
+			);
+			path = handler;
+			sourceTree = "<group>";
+		};
+		16C7CBC8147D4A4300776EAD /* sender */ = {
+			isa = PBXGroup;
+			children = (
+				16C7CBEA147D4A4300776EAD /* uploader.h */,
+				16C7CBEB147D4A4300776EAD /* uploader.mm */,
+			);
+			path = sender;
+			sourceTree = "<group>";
+		};
+		16C7CC47147D4A4300776EAD /* common */ = {
+			isa = PBXGroup;
+			children = (
+				16C7CC4A147D4A4300776EAD /* convert_UTF.c */,
+				16C7CC4B147D4A4300776EAD /* convert_UTF.h */,
+				16C7CC82147D4A4300776EAD /* mac */,
+				16C7CCA4147D4A4300776EAD /* md5.cc */,
+				16C7CCA5147D4A4300776EAD /* md5.h */,
+				16C7CCB9147D4A4300776EAD /* string_conversion.cc */,
+				16C7CCBA147D4A4300776EAD /* string_conversion.h */,
+			);
+			name = common;
+			path = ../../common;
+			sourceTree = SOURCE_ROOT;
+		};
+		16C7CC82147D4A4300776EAD /* mac */ = {
+			isa = PBXGroup;
+			children = (
+				16C7CC88147D4A4300776EAD /* GTMLogger.h */,
+				16C7CC89147D4A4300776EAD /* GTMLogger.m */,
+				16C7CC8A147D4A4300776EAD /* HTTPMultipartUpload.h */,
+				16C7CC8B147D4A4300776EAD /* HTTPMultipartUpload.m */,
+				16C7CC8E147D4A4300776EAD /* SimpleStringDictionary.h */,
+				16C7CC8F147D4A4300776EAD /* SimpleStringDictionary.mm */,
+				16C7CC93147D4A4300776EAD /* file_id.cc */,
+				16C7CC94147D4A4300776EAD /* file_id.h */,
+				16C7CC95147D4A4300776EAD /* macho_id.cc */,
+				16C7CC96147D4A4300776EAD /* macho_id.h */,
+				16C7CC9A147D4A4300776EAD /* macho_utilities.cc */,
+				16C7CC9B147D4A4300776EAD /* macho_utilities.h */,
+				16C7CC9C147D4A4300776EAD /* macho_walker.cc */,
+				16C7CC9D147D4A4300776EAD /* macho_walker.h */,
+				16C7CC9F147D4A4300776EAD /* string_utilities.cc */,
+				16C7CCA0147D4A4300776EAD /* string_utilities.h */,
+			);
+			path = mac;
+			sourceTree = "<group>";
+		};
+		32C88DFF0371C24200C91783 /* Other Sources */ = {
+			isa = PBXGroup;
+			children = (
+				AA747D9E0F9514B9006C5449 /* Breakpad_Prefix.pch */,
+			);
+			name = "Other Sources";
+			sourceTree = "<group>";
+		};
+/* End PBXGroup section */
+
+/* Begin PBXHeadersBuildPhase section */
+		D2AAC07A0554694100DB518D /* Headers */ = {
+			isa = PBXHeadersBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				AA747D9F0F9514B9006C5449 /* Breakpad_Prefix.pch in Headers */,
+				16C7CCCB147D4A4300776EAD /* BreakpadDefines.h in Headers */,
+				16C7CCCC147D4A4300776EAD /* Breakpad.h in Headers */,
+				16C7CDE8147D4A4300776EAD /* ConfigFile.h in Headers */,
+				16C7CDF6147D4A4300776EAD /* breakpad_nlist_64.h in Headers */,
+				16C7CDF8147D4A4300776EAD /* dynamic_images.h in Headers */,
+				16C7CDFA147D4A4300776EAD /* exception_handler.h in Headers */,
+				16C7CDFD147D4A4300776EAD /* minidump_generator.h in Headers */,
+				16C7CDFF147D4A4300776EAD /* protected_memory_allocator.h in Headers */,
+				16C7CE08147D4A4300776EAD /* uploader.h in Headers */,
+				16C7CE18147D4A4300776EAD /* minidump_file_writer-inl.h in Headers */,
+				16C7CE1A147D4A4300776EAD /* minidump_file_writer.h in Headers */,
+				16C7CE41147D4A4300776EAD /* convert_UTF.h in Headers */,
+				16C7CE78147D4A4300776EAD /* GTMLogger.h in Headers */,
+				16C7CE7A147D4A4300776EAD /* HTTPMultipartUpload.h in Headers */,
+				16C7CE7E147D4A4300776EAD /* SimpleStringDictionary.h in Headers */,
+				16C7CE84147D4A4300776EAD /* file_id.h in Headers */,
+				16C7CE86147D4A4300776EAD /* macho_id.h in Headers */,
+				16C7CE8B147D4A4300776EAD /* macho_utilities.h in Headers */,
+				16C7CE8D147D4A4300776EAD /* macho_walker.h in Headers */,
+				16C7CE90147D4A4300776EAD /* string_utilities.h in Headers */,
+				16C7CE94147D4A4300776EAD /* md5.h in Headers */,
+				16C7CEA8147D4A4300776EAD /* string_conversion.h in Headers */,
+				16BFA67014E195E9009704F8 /* ios_exception_minidump_generator.h in Headers */,
+				16C92FAD150DF8330053D7BA /* BreakpadController.h in Headers */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXHeadersBuildPhase section */
+
+/* Begin PBXNativeTarget section */
+		D2AAC07D0554694100DB518D /* Breakpad */ = {
+			isa = PBXNativeTarget;
+			buildConfigurationList = 1DEB921E08733DC00010E9CD /* Build configuration list for PBXNativeTarget "Breakpad" */;
+			buildPhases = (
+				D2AAC07A0554694100DB518D /* Headers */,
+				D2AAC07B0554694100DB518D /* Sources */,
+				D2AAC07C0554694100DB518D /* Frameworks */,
+			);
+			buildRules = (
+			);
+			dependencies = (
+			);
+			name = Breakpad;
+			productName = Breakpad;
+			productReference = D2AAC07E0554694100DB518D /* libBreakpad.a */;
+			productType = "com.apple.product-type.library.static";
+		};
+/* End PBXNativeTarget section */
+
+/* Begin PBXProject section */
+		0867D690FE84028FC02AAC07 /* Project object */ = {
+			isa = PBXProject;
+			buildConfigurationList = 1DEB922208733DC00010E9CD /* Build configuration list for PBXProject "Breakpad" */;
+			compatibilityVersion = "Xcode 3.2";
+			developmentRegion = English;
+			hasScannedForEncodings = 1;
+			knownRegions = (
+				English,
+				Japanese,
+				French,
+				German,
+				da,
+				de,
+				es,
+				fr,
+				it,
+				ja,
+				nl,
+				no,
+				sl,
+				sv,
+				tr,
+			);
+			mainGroup = 0867D691FE84028FC02AAC07 /* Breakpad */;
+			productRefGroup = 034768DFFF38A50411DB9C8B /* Products */;
+			projectDirPath = "";
+			projectRoot = "";
+			targets = (
+				D2AAC07D0554694100DB518D /* Breakpad */,
+			);
+		};
+/* End PBXProject section */
+
+/* Begin PBXSourcesBuildPhase section */
+		D2AAC07B0554694100DB518D /* Sources */ = {
+			isa = PBXSourcesBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				16C7CCCD147D4A4300776EAD /* Breakpad.mm in Sources */,
+				16C7CDE9147D4A4300776EAD /* ConfigFile.mm in Sources */,
+				16C7CDF5147D4A4300776EAD /* breakpad_nlist_64.cc in Sources */,
+				16C7CDF7147D4A4300776EAD /* dynamic_images.cc in Sources */,
+				16C7CDF9147D4A4300776EAD /* exception_handler.cc in Sources */,
+				16C7CDFC147D4A4300776EAD /* minidump_generator.cc in Sources */,
+				16C7CDFE147D4A4300776EAD /* protected_memory_allocator.cc in Sources */,
+				16C7CE09147D4A4300776EAD /* uploader.mm in Sources */,
+				16C7CE19147D4A4300776EAD /* minidump_file_writer.cc in Sources */,
+				16C7CE1B147D4A4300776EAD /* minidump_file_writer_unittest.cc in Sources */,
+				16C7CE40147D4A4300776EAD /* convert_UTF.c in Sources */,
+				16C7CE79147D4A4300776EAD /* GTMLogger.m in Sources */,
+				16C7CE7B147D4A4300776EAD /* HTTPMultipartUpload.m in Sources */,
+				16C7CE7F147D4A4300776EAD /* SimpleStringDictionary.mm in Sources */,
+				16C7CE83147D4A4300776EAD /* file_id.cc in Sources */,
+				16C7CE85147D4A4300776EAD /* macho_id.cc in Sources */,
+				16C7CE8A147D4A4300776EAD /* macho_utilities.cc in Sources */,
+				16C7CE8C147D4A4300776EAD /* macho_walker.cc in Sources */,
+				16C7CE8F147D4A4300776EAD /* string_utilities.cc in Sources */,
+				16C7CE93147D4A4300776EAD /* md5.cc in Sources */,
+				16C7CEA7147D4A4300776EAD /* string_conversion.cc in Sources */,
+				16BFA67214E1965A009704F8 /* ios_exception_minidump_generator.mm in Sources */,
+				16C92FAE150DF8330053D7BA /* BreakpadController.mm in Sources */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXSourcesBuildPhase section */
+
+/* Begin XCBuildConfiguration section */
+		1DEB921F08733DC00010E9CD /* Debug */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				ALWAYS_SEARCH_USER_PATHS = NO;
+				ARCHS = "$(ARCHS_STANDARD_32_BIT)";
+				COPY_PHASE_STRIP = NO;
+				DSTROOT = /tmp/Breakpad.dst;
+				FRAMEWORK_SEARCH_PATHS = (
+					"$(inherited)",
+					"\"$(SRCROOT)/../mac/build/Debug\"",
+				);
+				GCC_DYNAMIC_NO_PIC = NO;
+				GCC_MODEL_TUNING = G5;
+				GCC_OPTIMIZATION_LEVEL = 0;
+				GCC_PRECOMPILE_PREFIX_HEADER = YES;
+				GCC_PREFIX_HEADER = Breakpad_Prefix.pch;
+				INSTALL_PATH = /usr/local/lib;
+				LIBRARY_SEARCH_PATHS = (
+					"$(inherited)",
+					"\"$(SRCROOT)/../mac/build/Breakpad.build/Debug/Breakpad.build/Objects-normal/i386\"",
+					"\"$(SRCROOT)/../mac/build/Breakpad.build/Debug/Breakpad.build/Objects-normal/x86_64\"",
+					"\"$(SRCROOT)/../mac/build/Breakpad.build/Debug/breakpadUtilities.build/Objects-normal/i386\"",
+					"\"$(SRCROOT)/../mac/build/Breakpad.build/Debug/breakpadUtilities.build/Objects-normal/x86_64\"",
+					"\"$(SRCROOT)/../mac/build/Breakpad.build/Debug/gtest.build/Objects-normal/i386\"",
+					"\"$(SRCROOT)/../mac/build/Breakpad.build/Debug/gtest.build/Objects-normal/x86_64\"",
+					"\"$(SRCROOT)/../mac/build/Debug\"",
+					"\"$(SRCROOT)/../mac/gcov\"",
+				);
+				PRODUCT_NAME = Breakpad;
+			};
+			name = Debug;
+		};
+		1DEB922008733DC00010E9CD /* Release */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				ALWAYS_SEARCH_USER_PATHS = NO;
+				ARCHS = "$(ARCHS_STANDARD_32_BIT)";
+				DSTROOT = /tmp/Breakpad.dst;
+				FRAMEWORK_SEARCH_PATHS = (
+					"$(inherited)",
+					"\"$(SRCROOT)/../mac/build/Debug\"",
+				);
+				GCC_MODEL_TUNING = G5;
+				GCC_PRECOMPILE_PREFIX_HEADER = YES;
+				GCC_PREFIX_HEADER = Breakpad_Prefix.pch;
+				INSTALL_PATH = /usr/local/lib;
+				LIBRARY_SEARCH_PATHS = (
+					"$(inherited)",
+					"\"$(SRCROOT)/../mac/build/Breakpad.build/Debug/Breakpad.build/Objects-normal/i386\"",
+					"\"$(SRCROOT)/../mac/build/Breakpad.build/Debug/Breakpad.build/Objects-normal/x86_64\"",
+					"\"$(SRCROOT)/../mac/build/Breakpad.build/Debug/breakpadUtilities.build/Objects-normal/i386\"",
+					"\"$(SRCROOT)/../mac/build/Breakpad.build/Debug/breakpadUtilities.build/Objects-normal/x86_64\"",
+					"\"$(SRCROOT)/../mac/build/Breakpad.build/Debug/gtest.build/Objects-normal/i386\"",
+					"\"$(SRCROOT)/../mac/build/Breakpad.build/Debug/gtest.build/Objects-normal/x86_64\"",
+					"\"$(SRCROOT)/../mac/build/Debug\"",
+					"\"$(SRCROOT)/../mac/gcov\"",
+				);
+				PRODUCT_NAME = Breakpad;
+			};
+			name = Release;
+		};
+		1DEB922308733DC00010E9CD /* Debug */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				ARCHS = "$(ARCHS_STANDARD_32_BIT)";
+				CLANG_WARN_SUSPICIOUS_IMPLICIT_CONVERSION = YES;
+				GCC_C_LANGUAGE_STANDARD = c99;
+				GCC_OPTIMIZATION_LEVEL = 0;
+				GCC_WARN_64_TO_32_BIT_CONVERSION = YES;
+				GCC_WARN_ABOUT_RETURN_TYPE = YES;
+				GCC_WARN_SHADOW = YES;
+				GCC_WARN_SIGN_COMPARE = YES;
+				GCC_WARN_UNINITIALIZED_AUTOS = YES;
+				GCC_WARN_UNKNOWN_PRAGMAS = YES;
+				GCC_WARN_UNUSED_FUNCTION = YES;
+				GCC_WARN_UNUSED_LABEL = YES;
+				GCC_WARN_UNUSED_VARIABLE = YES;
+				HEADER_SEARCH_PATHS = (
+					../../,
+					../../client/apple/Framework,
+					../../common/mac,
+				);
+				OTHER_LDFLAGS = "-ObjC";
+				SDKROOT = iphoneos;
+			};
+			name = Debug;
+		};
+		1DEB922408733DC00010E9CD /* Release */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				ARCHS = "$(ARCHS_STANDARD_32_BIT)";
+				CLANG_WARN_SUSPICIOUS_IMPLICIT_CONVERSION = YES;
+				GCC_C_LANGUAGE_STANDARD = c99;
+				GCC_WARN_64_TO_32_BIT_CONVERSION = YES;
+				GCC_WARN_ABOUT_RETURN_TYPE = YES;
+				GCC_WARN_SHADOW = YES;
+				GCC_WARN_SIGN_COMPARE = YES;
+				GCC_WARN_UNINITIALIZED_AUTOS = YES;
+				GCC_WARN_UNKNOWN_PRAGMAS = YES;
+				GCC_WARN_UNUSED_FUNCTION = YES;
+				GCC_WARN_UNUSED_LABEL = YES;
+				GCC_WARN_UNUSED_VARIABLE = YES;
+				HEADER_SEARCH_PATHS = (
+					../../,
+					../../client/apple/Framework,
+					../../common/mac,
+				);
+				OTHER_LDFLAGS = "-ObjC";
+				SDKROOT = iphoneos;
+			};
+			name = Release;
+		};
+/* End XCBuildConfiguration section */
+
+/* Begin XCConfigurationList section */
+		1DEB921E08733DC00010E9CD /* Build configuration list for PBXNativeTarget "Breakpad" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				1DEB921F08733DC00010E9CD /* Debug */,
+				1DEB922008733DC00010E9CD /* Release */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
+		};
+		1DEB922208733DC00010E9CD /* Build configuration list for PBXProject "Breakpad" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				1DEB922308733DC00010E9CD /* Debug */,
+				1DEB922408733DC00010E9CD /* Release */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
+		};
+/* End XCConfigurationList section */
+	};
+	rootObject = 0867D690FE84028FC02AAC07 /* Project object */;
+}

toolkit/crashreporter/google-breakpad/src/client/ios/BreakpadController.h

@@ -0,0 +1,106 @@
+// Copyright (c) 2012, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef CLIENT_IOS_HANDLER_IOS_BREAKPAD_CONTROLLER_H_
+#define CLIENT_IOS_HANDLER_IOS_BREAKPAD_CONTROLLER_H_
+
+#import <Foundation/Foundation.h>
+
+#import "client/ios/Breakpad.h"
+
+// This class is used to offer a higher level API around BreakpadRef. It
+// configures it, ensures thread-safety, and sends crash reports back to the
+// collecting server. By default, no crash reports are sent, the user must call
+// |setUploadingEnabled:YES| to start the uploading.
+@interface BreakpadController : NSObject {
+ @private
+  // The dispatch queue that will own the breakpad reference.
+  dispatch_queue_t queue_;
+
+  // Instance of Breakpad crash reporter. This is owned by the queue, but can
+  // be created on the main thread at startup.
+  BreakpadRef breakpadRef_;
+
+  // The dictionary that contains configuration for breakpad. Modifying it
+  // should only happen when the controller is not started. The initial value
+  // is the infoDictionary of the bundle of the application.
+  NSMutableDictionary* configuration_;
+
+  // Whether or not crash reports should be uploaded.
+  BOOL enableUploads_;
+
+  // The interval to wait between two uploads. Value is 0 if no upload must be
+  // done.
+  int uploadIntervalInSeconds_;
+}
+
+// Singleton.
++ (BreakpadController*)sharedInstance;
+
+// Update the controller configuration. Merges its old configuration with the
+// new one. Merge is done by replacing the old values by the new values.
+- (void)updateConfiguration:(NSDictionary*)configuration;
+
+// Configure the URL to upload the report to. This must be called at least once
+// if the URL is not in the bundle information.
+- (void)setUploadingURL:(NSString*)url;
+
+// Set the minimal interval between two uploads in seconds. This must be called
+// at least once if the interval is not in the bundle information. A value of 0
+// will prevent uploads.
+- (void)setUploadInterval:(int)intervalInSeconds;
+
+// Specify a parameter that will be uploaded to the crash server. See
+// |BreakpadAddUploadParameter|.
+- (void)addUploadParameter:(NSString*)value forKey:(NSString*)key;
+
+// Remove a previously-added parameter from the upload parameter set. See
+// |BreakpadRemoveUploadParameter|.
+- (void)removeUploadParameterForKey:(NSString*)key;
+
+// Access the underlying BreakpadRef. This method is asynchronous, and will be
+// executed on the thread owning the BreakpadRef variable. Moreover, if the
+// controller is not started, the block will be called with a NULL parameter.
+- (void)withBreakpadRef:(void(^)(BreakpadRef))callback;
+
+// Starts the BreakpadController by registering crash handlers. If
+// |onCurrentThread| is YES, all setup is done on the current thread, otherwise
+// it is done on a private queue.
+- (void)start:(BOOL)onCurrentThread;
+
+// Unregisters the crash handlers.
+- (void)stop;
+
+// Enables or disables uploading of crash reports, but does not stop the
+// BreakpadController.
+- (void)setUploadingEnabled:(BOOL)enabled;
+
+@end
+
+#endif  // CLIENT_IOS_HANDLER_IOS_BREAKPAD_CONTROLLER_H_

toolkit/crashreporter/google-breakpad/src/client/ios/BreakpadController.mm

@@ -0,0 +1,266 @@
+// Copyright (c) 2012, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#import "BreakpadController.h"
+
+#import <UIKit/UIKit.h>
+#include <asl.h>
+#include <execinfo.h>
+#include <signal.h>
+#include <unistd.h>
+#include <sys/sysctl.h>
+
+#include <processor/scoped_ptr.h>
+
+#pragma mark -
+#pragma mark Private Methods
+
+@interface BreakpadController ()
+
+// Init the singleton instance.
+- (id)initSingleton;
+
+// Load a crash report and send it to the server.
+- (void)sendStoredCrashReports;
+
+// Returns when a report can be sent. |-1| means never, |0| means that a report
+// can be sent immediately, a positive number is the number of seconds to wait
+// before being allowed to upload a report.
+- (int)sendDelay;
+
+// Notifies that a report will be sent, and update the last sending time
+// accordingly.
+- (void)reportWillBeSent;
+
+@end
+
+#pragma mark -
+#pragma mark Anonymous namespace
+
+namespace {
+
+// The name of the user defaults key for the last submission to the crash
+// server.
+NSString* const kLastSubmission = @"com.google.Breakpad.LastSubmission";
+
+// Returns a NSString describing the current platform.
+NSString* GetPlatform() {
+  // Name of the system call for getting the platform.
+  static const char kHwMachineSysctlName[] = "hw.machine";
+
+  NSString* result = nil;
+
+  size_t size = 0;
+  if (sysctlbyname(kHwMachineSysctlName, NULL, &size, NULL, 0) || size == 0)
+    return nil;
+  google_breakpad::scoped_array<char> machine(new char[size]);
+  if (sysctlbyname(kHwMachineSysctlName, machine.get(), &size, NULL, 0) == 0)
+    result = [NSString stringWithUTF8String:machine.get()];
+  return result;
+}
+
+}  // namespace
+
+#pragma mark -
+#pragma mark BreakpadController Implementation
+
+@implementation BreakpadController
+
++ (BreakpadController*)sharedInstance {
+  @synchronized(self) {
+    static BreakpadController* sharedInstance_ =
+        [[BreakpadController alloc] initSingleton];
+    return sharedInstance_;
+  }
+}
+
+- (id)init {
+  return nil;
+}
+
+- (id)initSingleton {
+  self = [super init];
+  if (self) {
+    queue_ = dispatch_queue_create("com.google.BreakpadQueue", NULL);
+    configuration_ = [[[NSBundle mainBundle] infoDictionary] mutableCopy];
+    enableUploads_ = NO;
+    NSString* uploadInterval =
+        [configuration_ valueForKey:@BREAKPAD_REPORT_INTERVAL];
+    [self setUploadInterval:[uploadInterval intValue]];
+  }
+  return self;
+}
+
+// Since this class is a singleton, this method is not expected to be called.
+- (void)dealloc {
+  assert(!breakpadRef_);
+  dispatch_release(queue_);
+  [configuration_ release];
+  [super dealloc];
+}
+
+#pragma mark -
+
+- (void)start:(BOOL)onCurrentThread {
+  void(^startBlock)() = ^{
+      assert(!breakpadRef_);
+      breakpadRef_ = BreakpadCreate(configuration_);
+      if (breakpadRef_) {
+        BreakpadAddUploadParameter(breakpadRef_, @"platform", GetPlatform());
+      }
+  };
+  if (onCurrentThread)
+    startBlock();
+  else
+    dispatch_async(queue_, startBlock);
+}
+
+- (void)stop {
+  dispatch_sync(queue_, ^{
+      if (breakpadRef_) {
+        BreakpadRelease(breakpadRef_);
+        breakpadRef_ = NULL;
+      }
+  });
+}
+
+- (void)setUploadingEnabled:(BOOL)enabled {
+  dispatch_async(queue_, ^{
+      if (enabled == enableUploads_)
+        return;
+      if (enabled) {
+        // Set this before calling doSendStoredCrashReport, because that
+        // calls sendDelay, which in turn checks this flag.
+        enableUploads_ = YES;
+        [self sendStoredCrashReports];
+      } else {
+        enableUploads_ = NO;
+        [NSObject cancelPreviousPerformRequestsWithTarget:self
+            selector:@selector(sendStoredCrashReports)
+            object:nil];
+      }
+  });
+}
+
+- (void)updateConfiguration:(NSDictionary*)configuration {
+  [configuration_ addEntriesFromDictionary:configuration];
+  NSString* uploadInterval =
+      [configuration_ valueForKey:@BREAKPAD_REPORT_INTERVAL];
+  if (uploadInterval)
+    [self setUploadInterval:[uploadInterval intValue]];
+}
+
+- (void)setUploadingURL:(NSString*)url {
+  [configuration_ setValue:url forKey:@BREAKPAD_URL];
+}
+
+- (void)setUploadInterval:(int)intervalInSeconds {
+  [configuration_ removeObjectForKey:@BREAKPAD_REPORT_INTERVAL];
+  uploadIntervalInSeconds_ = intervalInSeconds;
+  if (uploadIntervalInSeconds_ < 0)
+    uploadIntervalInSeconds_ = 0;
+}
+
+- (void)addUploadParameter:(NSString*)value forKey:(NSString*)key {
+  dispatch_async(queue_, ^{
+      if (breakpadRef_)
+        BreakpadAddUploadParameter(breakpadRef_, key, value);
+  });
+}
+
+- (void)removeUploadParameterForKey:(NSString*)key {
+  dispatch_async(queue_, ^{
+      if (breakpadRef_)
+        BreakpadRemoveUploadParameter(breakpadRef_, key);
+  });
+}
+
+- (void)withBreakpadRef:(void(^)(BreakpadRef))callback {
+  dispatch_async(queue_, ^{
+      callback(breakpadRef_);
+  });
+}
+
+
+#pragma mark -
+
+- (int)sendDelay {
+  if (!breakpadRef_ || uploadIntervalInSeconds_ <= 0 || !enableUploads_)
+    return -1;
+
+  // To prevent overloading the crash server, crashes are not sent than one
+  // report every |uploadIntervalInSeconds_|. A value in the user defaults is
+  // used to keep the time of the last upload.
+  NSUserDefaults *userDefaults = [NSUserDefaults standardUserDefaults];
+  NSNumber *lastTimeNum = [userDefaults objectForKey:kLastSubmission];
+  NSTimeInterval lastTime = lastTimeNum ? [lastTimeNum floatValue] : 0;
+  NSTimeInterval spanSeconds = CFAbsoluteTimeGetCurrent() - lastTime;
+
+  if (spanSeconds >= uploadIntervalInSeconds_)
+    return 0;
+  return uploadIntervalInSeconds_ - static_cast<int>(spanSeconds);
+}
+
+- (void)reportWillBeSent {
+  NSUserDefaults *userDefaults = [NSUserDefaults standardUserDefaults];
+  [userDefaults setObject:[NSNumber numberWithDouble:CFAbsoluteTimeGetCurrent()]
+                   forKey:kLastSubmission];
+  [userDefaults synchronize];
+}
+
+- (void)sendStoredCrashReports {
+  dispatch_async(queue_, ^{
+      if (!BreakpadHasCrashReportToUpload(breakpadRef_))
+        return;
+
+      int timeToWait = [self sendDelay];
+
+      // Unable to ever send report.
+      if (timeToWait == -1)
+        return;
+
+      // A report can be sent now.
+      if (timeToWait == 0) {
+        [self reportWillBeSent];
+        BreakpadUploadNextReport(breakpadRef_);
+
+        // If more reports must be sent, make sure this method is called again.
+        if (BreakpadHasCrashReportToUpload(breakpadRef_))
+          timeToWait = uploadIntervalInSeconds_;
+      }
+
+      // A report must be sent later.
+      if (timeToWait > 0)
+        [self performSelector:@selector(sendStoredCrashReports)
+                   withObject:nil
+                   afterDelay:timeToWait];
+  });
+}
+
+@end

toolkit/crashreporter/google-breakpad/src/client/ios/Breakpad_Prefix.pch

@@ -0,0 +1,7 @@
+//
+// Prefix header for all source files of the 'CocoaTouchStaticLibrary' target in the 'CocoaTouchStaticLibrary' project.
+//
+
+#ifdef __OBJC__
+    #import <Foundation/Foundation.h>
+#endif

toolkit/crashreporter/google-breakpad/src/client/ios/handler/ios_exception_minidump_generator.h

@@ -0,0 +1,64 @@
+// Copyright (c) 2012, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// ios_exception_minidump_generator.h:  Create a fake minidump from a
+// NSException.
+
+#ifndef CLIENT_IOS_HANDLER_IOS_EXCEPTION_MINIDUMP_GENERATOR_H_
+#define CLIENT_IOS_HANDLER_IOS_EXCEPTION_MINIDUMP_GENERATOR_H_
+
+#include <Foundation/Foundation.h>
+
+#include "client/mac/handler/minidump_generator.h"
+
+namespace google_breakpad {
+
+class IosExceptionMinidumpGenerator : public MinidumpGenerator {
+ public:
+  explicit IosExceptionMinidumpGenerator(NSException *exception);
+  virtual ~IosExceptionMinidumpGenerator();
+
+ protected:
+  virtual bool WriteExceptionStream(MDRawDirectory *exception_stream);
+  virtual bool WriteThreadStream(mach_port_t thread_id, MDRawThread *thread);
+
+ private:
+
+  // Get the crashing program counter from the exception.
+  uint32_t GetPCFromException();
+
+  // Write a virtual thread context for the crashing site.
+  bool WriteCrashingContext(MDLocationDescriptor *register_location);
+
+  NSArray *return_addresses_;
+};
+
+}  // namespace google_breakpad
+
+#endif  // CLIENT_IOS_HANDLER_IOS_EXCEPTION_MINIDUMP_GENERATOR_H_

toolkit/crashreporter/google-breakpad/src/client/ios/handler/ios_exception_minidump_generator.mm

@@ -0,0 +1,168 @@
+// Copyright (c) 2012, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#include "client/ios/handler/ios_exception_minidump_generator.h"
+
+#include "google_breakpad/common/minidump_exception_mac.h"
+#include "client/minidump_file_writer-inl.h"
+#include "processor/scoped_ptr.h"
+
+namespace {
+
+const uint32_t kExpectedFinalFp = 4;
+const uint32_t kExpectedFinalSp = 0;
+const int kExceptionType = EXC_SOFTWARE;
+const int kExceptionCode = MD_EXCEPTION_CODE_MAC_NS_EXCEPTION;
+
+#ifdef HAS_ARM_SUPPORT
+// Append the given 4 bytes value to the sp position of the stack represented
+// by memory.
+void AppendToMemory(uint8_t *memory, uint32_t sp, uint32_t data) {
+  assert(sizeof(data) == 4);
+  memcpy(memory + sp, &data, sizeof(data));
+}
+#endif
+
+}  // namespace
+
+namespace google_breakpad {
+
+IosExceptionMinidumpGenerator::IosExceptionMinidumpGenerator(
+    NSException *exception)
+    : MinidumpGenerator(mach_task_self(), 0) {
+  return_addresses_ = [[exception callStackReturnAddresses] retain];
+  SetExceptionInformation(kExceptionType,
+                          kExceptionCode,
+                          0,
+                          pthread_mach_thread_np(pthread_self()));
+}
+
+IosExceptionMinidumpGenerator::~IosExceptionMinidumpGenerator() {
+  [return_addresses_ release];
+}
+
+bool IosExceptionMinidumpGenerator::WriteCrashingContext(
+    MDLocationDescriptor *register_location) {
+#ifdef HAS_ARM_SUPPORT
+  TypedMDRVA<MDRawContextARM> context(&writer_);
+  if (!context.Allocate())
+    return false;
+  *register_location = context.location();
+  MDRawContextARM *context_ptr = context.get();
+  memset(context_ptr, 0, sizeof(MDRawContextARM));
+  context_ptr->context_flags = MD_CONTEXT_ARM_FULL;
+  context_ptr->iregs[7] = kExpectedFinalFp;  // FP
+  context_ptr->iregs[13] = kExpectedFinalSp;  // SP
+  uint32_t pc = GetPCFromException();
+  context_ptr->iregs[14] = pc;  // LR
+  context_ptr->iregs[15] = pc;  // PC
+  return true;
+#else
+  assert(false);
+  return false;
+#endif
+}
+
+uint32_t IosExceptionMinidumpGenerator::GetPCFromException() {
+  return [[return_addresses_ objectAtIndex:0] unsignedIntegerValue];
+}
+
+bool IosExceptionMinidumpGenerator::WriteExceptionStream(
+    MDRawDirectory *exception_stream) {
+#ifdef HAS_ARM_SUPPORT
+  TypedMDRVA<MDRawExceptionStream> exception(&writer_);
+
+  if (!exception.Allocate())
+    return false;
+
+  exception_stream->stream_type = MD_EXCEPTION_STREAM;
+  exception_stream->location = exception.location();
+  MDRawExceptionStream *exception_ptr = exception.get();
+  exception_ptr->thread_id = pthread_mach_thread_np(pthread_self());
+
+  // This naming is confusing, but it is the proper translation from
+  // mach naming to minidump naming.
+  exception_ptr->exception_record.exception_code = kExceptionType;
+  exception_ptr->exception_record.exception_flags = kExceptionCode;
+
+  if (!WriteCrashingContext(&exception_ptr->thread_context))
+    return false;
+
+  exception_ptr->exception_record.exception_address = GetPCFromException();
+  return true;
+#else
+  return MinidumpGenerator::WriteExceptionStream(exception_stream);
+#endif
+}
+
+bool IosExceptionMinidumpGenerator::WriteThreadStream(mach_port_t thread_id,
+                                                      MDRawThread *thread) {
+#ifdef HAS_ARM_SUPPORT
+  if (pthread_mach_thread_np(pthread_self()) != thread_id)
+    return MinidumpGenerator::WriteThreadStream(thread_id, thread);
+
+  size_t frame_count = [return_addresses_ count];
+  UntypedMDRVA memory(&writer_);
+  size_t size = 8 * (frame_count - 1) + 4;
+  if (!memory.Allocate(size))
+    return false;
+  scoped_array<uint8_t> stack_memory(new uint8_t[size]);
+  uint32_t sp = size - 4;
+  uint32_t fp = 0;
+  uint32_t lr = [[return_addresses_ lastObject] unsignedIntegerValue];
+  for (int current_frame = frame_count - 2;
+       current_frame >= 0;
+       --current_frame) {
+    AppendToMemory(stack_memory.get(), sp, fp);
+    sp -= 4;
+    fp = sp;
+    AppendToMemory(stack_memory.get(), sp, lr);
+    sp -= 4;
+    lr = [[return_addresses_ objectAtIndex:current_frame] unsignedIntegerValue];
+  }
+  if (!memory.Copy(stack_memory.get(), size))
+    return false;
+  assert(sp == kExpectedFinalSp);
+  assert(fp == kExpectedFinalFp);
+  assert(lr == GetPCFromException());
+  thread->stack.start_of_memory_range = sp;
+  thread->stack.memory = memory.location();
+  memory_blocks_.push_back(thread->stack);
+
+  if (!WriteCrashingContext(&thread->thread_context))
+    return false;
+
+  thread->thread_id = thread_id;
+  return true;
+#else
+  return MinidumpGenerator::WriteThreadStream(thread_id, thread);
+#endif
+}
+
+}  // namespace google_breakpad

toolkit/crashreporter/google-breakpad/src/client/linux/android_link.h

@@ -1,4 +0,0 @@
-#include <sys/exec_elf.h>
-#define ElfW(type)	_ElfW (Elf, ELFSIZE, type)
-#define _ElfW(e,w,t)	_ElfW_1 (e, w, _##t)
-#define _ElfW_1(e,w,t)	e##w##t

toolkit/crashreporter/google-breakpad/src/client/linux/android_ucontext.h

@@ -1,46 +0,0 @@
-#ifndef GOOGLE_BREAKPAD_CLIENT_LINUX_ANDROID_UCONTEXT_H_
-#define GOOGLE_BREAKPAD_CLIENT_LINUX_ANDROID_UCONTEXT_H_
-
-#include <signal.h>
-
-// Adapted from platform-linux.cc in V8
-#if !defined(__GLIBC__) && (defined(__arm__) || defined(__thumb__))
-// Android runs a fairly new Linux kernel, so signal info is there,
-// but the C library doesn't have the structs defined.
-
-struct sigcontext {
-  uint32_t trap_no;
-  uint32_t error_code;
-  uint32_t oldmask;
-  uint32_t arm_r0;
-  uint32_t arm_r1;
-  uint32_t arm_r2;
-  uint32_t arm_r3;
-  uint32_t arm_r4;
-  uint32_t arm_r5;
-  uint32_t arm_r6;
-  uint32_t arm_r7;
-  uint32_t arm_r8;
-  uint32_t arm_r9;
-  uint32_t arm_r10;
-  uint32_t arm_fp;
-  uint32_t arm_ip;
-  uint32_t arm_sp;
-  uint32_t arm_lr;
-  uint32_t arm_pc;
-  uint32_t arm_cpsr;
-  uint32_t fault_address;
-};
-typedef uint32_t __sigset_t;
-typedef struct sigcontext mcontext_t;
-typedef struct ucontext {
-  uint32_t uc_flags;
-  struct ucontext* uc_link;
-  stack_t uc_stack;
-  mcontext_t uc_mcontext;
-  __sigset_t uc_sigmask;
-} ucontext_t;
-
-#endif
-
-#endif  // GOOGLE_BREAKPAD_CLIENT_LINUX_ANDROID_UCONTEXT_H_

toolkit/crashreporter/google-breakpad/src/client/linux/crash_generation/Makefile.in

@@ -12,7 +12,9 @@ include $(DEPTH)/config/autoconf.mk
 MODULE		= crash_generation
 LIBRARY_NAME	= crash_generation_s
 
-LOCAL_INCLUDES 	= -I$(topsrcdir)/toolkit/crashreporter/google-breakpad/src
+LOCAL_INCLUDES = \
+  -I$(topsrcdir)/toolkit/crashreporter/google-breakpad/src \
+  $(NULL)
 
 CPPSRCS		=				\
   crash_generation_client.cc			\
@@ -27,3 +29,7 @@ ifeq ($(OS_ARCH),Linux)
 # need this to suppress errors when compiling common/linux/eintr_wrapper.h
 OS_CXXFLAGS := $(filter-out -pedantic,$(OS_CXXFLAGS))
 endif
+
+ifeq ($(OS_TARGET),Android)
+LOCAL_INCLUDES += -I$(topsrcdir)/toolkit/crashreporter/google-breakpad/src/common/android/include/
+endif

toolkit/crashreporter/google-breakpad/src/client/linux/crash_generation/client_info.h

@@ -34,13 +34,18 @@ namespace google_breakpad {
 
 class CrashGenerationServer;
 
-struct ClientInfo {
+class ClientInfo {
+ public:
+  ClientInfo(pid_t pid, CrashGenerationServer* crash_server)
+    : crash_server_(crash_server_),
+      pid_(pid) {}
+
+  CrashGenerationServer* crash_server() const { return crash_server_; }
   pid_t pid() const { return pid_; }
 
+ private:
   CrashGenerationServer* crash_server_;
   pid_t pid_;
-  char* crash_context;
-  size_t crash_context_size;
 };
 
 }

toolkit/crashreporter/google-breakpad/src/client/linux/crash_generation/crash_generation_client.cc

@@ -35,8 +35,9 @@
 
 #include "client/linux/crash_generation/crash_generation_client.h"
 #include "common/linux/eintr_wrapper.h"
+#include "common/linux/ignore_ret.h"
 #include "common/linux/linux_libc_support.h"
-#include "common/linux/linux_syscall_support.h"
+#include "third_party/lss/linux_syscall_support.h"
 
 namespace google_breakpad {
 
@@ -67,12 +68,14 @@ CrashGenerationClient::RequestDump(const void* blob, size_t blob_size)
   int* p = reinterpret_cast<int*>(CMSG_DATA(hdr));
   *p = fds[1];
 
-  HANDLE_EINTR(sys_sendmsg(server_fd_, &msg, 0));
+  ssize_t ret = HANDLE_EINTR(sys_sendmsg(server_fd_, &msg, 0));
   sys_close(fds[1]);
+  if (ret <= 0)
+    return false;
 
   // wait for an ACK from the server
   char b;
-  HANDLE_EINTR(sys_read(fds[0], &b, 1));
+  IGNORE_RET(HANDLE_EINTR(sys_read(fds[0], &b, 1)));
 
   return true;
 }

toolkit/crashreporter/google-breakpad/src/client/linux/crash_generation/crash_generation_server.cc

@@ -39,12 +39,15 @@
 #include <sys/types.h>
 #include <unistd.h>
 
+#include <vector>
+
 #include "client/linux/crash_generation/crash_generation_server.h"
 #include "client/linux/crash_generation/client_info.h"
 #include "client/linux/handler/exception_handler.h"
 #include "client/linux/minidump_writer/minidump_writer.h"
 #include "common/linux/eintr_wrapper.h"
 #include "common/linux/guid_creator.h"
+#include "common/linux/safe_readlink.h"
 
 static const char kCommandQuit = 'x';
 
@@ -77,12 +80,10 @@ GetInodeForProcPath(ino_t* inode_out, const char* path)
   assert(inode_out);
   assert(path);
 
-  char buf[256];
-  const ssize_t n = readlink(path, buf, sizeof(buf) - 1);
-  if (n == -1) {
+  char buf[PATH_MAX];
+  if (!google_breakpad::SafeReadLink(path, buf)) {
     return false;
   }
-  buf[n] = 0;
 
   if (0 != memcmp(kSocketLinkPrefix, buf, sizeof(kSocketLinkPrefix) - 1)) {
     return false;
@@ -128,7 +129,7 @@ FindProcessHoldingSocket(pid_t* pid_out, ino_t socket_inode)
   for (std::vector<pid_t>::const_iterator
        i = pids.begin(); i != pids.end(); ++i) {
     const pid_t current_pid = *i;
-    char buf[256];
+    char buf[PATH_MAX];
     snprintf(buf, sizeof(buf), "/proc/%d/fd", current_pid);
     DIR* fd = opendir(buf);
     if (!fd)
@@ -142,15 +143,15 @@ FindProcessHoldingSocket(pid_t* pid_out, ino_t socket_inode)
 
       ino_t fd_inode;
       if (GetInodeForProcPath(&fd_inode, buf)
-	  && fd_inode == socket_inode) {
-	if (already_found) {
-	  closedir(fd);
-	  return false;
-	}
+          && fd_inode == socket_inode) {
+        if (already_found) {
+          closedir(fd);
+          return false;
+        }
 
-	already_found = true;
-	*pid_out = current_pid;
-	break;
+        already_found = true;
+        *pid_out = current_pid;
+        break;
       }
     }
 
@@ -169,7 +170,7 @@ CrashGenerationServer::CrashGenerationServer(
   OnClientExitingCallback exit_callback,
   void* exit_context,
   bool generate_dumps,
-  const std::string* dump_path) :
+  const string* dump_path) :
     server_fd_(listen_fd),
     dump_callback_(dump_callback),
     dump_context_(dump_context),
@@ -224,11 +225,11 @@ CrashGenerationServer::Stop()
 {
   assert(pthread_self() != thread_);
 
- if (!started_)
-   return;
+  if (!started_)
+    return;
 
   HANDLE_EINTR(write(control_pipe_out_, &kCommandQuit, 1));
-  
+
   void* dummy;
   pthread_join(thread_, &dummy);
 
@@ -280,7 +281,7 @@ CrashGenerationServer::Run()
       if (EINTR == errno) {
         continue;
       } else {
-	return;
+        return;
       }
     }
 
@@ -383,12 +384,11 @@ CrashGenerationServer::ClientEvent(short revents)
     return true;
   }
 
-  std::string minidump_filename;
+  string minidump_filename;
   if (!MakeMinidumpFilename(minidump_filename))
     return true;
 
-  if (generate_dumps_ &&
-      !google_breakpad::WriteMinidump(minidump_filename.c_str(),
+  if (!google_breakpad::WriteMinidump(minidump_filename.c_str(),
                                       crashing_pid, crash_context,
                                       kCrashContextSize)) {
     HANDLE_EINTR(close(signal_fd));
@@ -396,12 +396,7 @@ CrashGenerationServer::ClientEvent(short revents)
   }
 
   if (dump_callback_) {
-    ClientInfo info;
-
-    info.crash_server_ = this;
-    info.pid_ = crashing_pid;
-    info.crash_context = crash_context;
-    info.crash_context_size = kCrashContextSize;
+    ClientInfo info(crashing_pid, this);
 
     dump_callback_(dump_context_, &info, &minidump_filename);
   }
@@ -442,7 +437,7 @@ CrashGenerationServer::ControlEvent(short revents)
 }
 
 bool
-CrashGenerationServer::MakeMinidumpFilename(std::string& outFilename)
+CrashGenerationServer::MakeMinidumpFilename(string& outFilename)
 {
   GUID guid;
   char guidString[kGUIDStringLength+1];
@@ -466,4 +461,4 @@ CrashGenerationServer::ThreadMain(void *arg)
   return NULL;
 }
 
-} // namespace google_breakpad
+}  // namespace google_breakpad

toolkit/crashreporter/google-breakpad/src/client/linux/crash_generation/crash_generation_server.h

@@ -34,6 +34,8 @@
 
 #include <string>
 
+#include "common/using_std_string.h"
+
 namespace google_breakpad {
 
 class ClientInfo;
@@ -45,7 +47,7 @@ public:
   // be thread safe.
   typedef void (*OnClientDumpRequestCallback)(void* context,
                                               const ClientInfo* client_info,
-                                              const std::string* file_path);
+                                              const string* file_path);
 
   typedef void (*OnClientExitingCallback)(void* context,
                                           const ClientInfo* client_info);
@@ -69,7 +71,7 @@ public:
                         OnClientExitingCallback exit_callback,
                         void* exit_context,
                         bool generate_dumps,
-                        const std::string* dump_path);
+                        const string* dump_path);
 
   ~CrashGenerationServer();
 
@@ -100,7 +102,7 @@ private:
   bool ControlEvent(short revents);
 
   // Return a unique filename at which a minidump can be written
-  bool MakeMinidumpFilename(std::string& outFilename);
+  bool MakeMinidumpFilename(string& outFilename);
 
   // Trampoline to |Run()|
   static void* ThreadMain(void* arg);
@@ -115,7 +117,7 @@ private:
 
   bool generate_dumps_;
 
-  std::string dump_dir_;
+  string dump_dir_;
 
   bool started_;
 

toolkit/crashreporter/google-breakpad/src/client/linux/handler/Makefile.in

@@ -27,10 +27,16 @@ MODULE		= handler
 LIBRARY_NAME	= exception_handler_s
 XPI_NAME 	= crashreporter
 
-LOCAL_INCLUDES 	= -I$(srcdir)/../../..
+VPATH += $(srcdir)/../log
+
+LOCAL_INCLUDES = \
+  -I$(topsrcdir)/toolkit/crashreporter/google-breakpad/src \
+  $(NULL)
 
 CPPSRCS	= \
   exception_handler.cc \
+  log.cc \
+  minidump_descriptor.cc \
   $(NULL)
 
 # need static lib
@@ -39,6 +45,7 @@ FORCE_STATIC_LIB = 1
 ifeq ($(OS_TARGET),Android)
 # NDK5 workarounds
 DEFINES += -D_STLP_CONST_CONSTRUCTOR_BUG -D_STLP_NO_MEMBER_TEMPLATES
+LOCAL_INCLUDES += -I$(topsrcdir)/toolkit/crashreporter/google-breakpad/src/common/android/include/
 endif
 
 include $(topsrcdir)/config/rules.mk

toolkit/crashreporter/google-breakpad/src/client/linux/handler/exception_handler.cc

@@ -73,31 +73,26 @@
 #include <stdio.h>
 #include <sys/mman.h>
 #include <sys/prctl.h>
-#if !defined(__ANDROID__)
-#include <sys/signal.h>
-#endif
 #include <sys/syscall.h>
-#if !defined(__ANDROID__)
+#include <sys/wait.h>
+#include <unistd.h>
+
+#include <sys/signal.h>
 #include <sys/ucontext.h>
 #include <sys/user.h>
-#endif
-#include <sys/wait.h>
-#if !defined(__ANDROID__)
 #include <ucontext.h>
-#endif
-#include <unistd.h>
 
 #include <algorithm>
 #include <utility>
 #include <vector>
 
 #include "common/linux/linux_libc_support.h"
-#include "common/linux/linux_syscall_support.h"
 #include "common/memory.h"
+#include "client/linux/log/log.h"
 #include "client/linux/minidump_writer/linux_dumper.h"
 #include "client/linux/minidump_writer/minidump_writer.h"
-#include "common/linux/guid_creator.h"
 #include "common/linux/eintr_wrapper.h"
+#include "third_party/lss/linux_syscall_support.h"
 
 #include "linux/sched.h"
 
@@ -113,93 +108,140 @@ static int tgkill(pid_t tgid, pid_t tid, int sig) {
 
 namespace google_breakpad {
 
+namespace {
 // The list of signals which we consider to be crashes. The default action for
 // all these signals must be Core (see man 7 signal) because we rethrow the
 // signal after handling it and expect that it'll be fatal.
-static const int kExceptionSignals[] = {
-  SIGSEGV, SIGABRT, SIGFPE, SIGILL, SIGBUS, -1
+const int kExceptionSignals[] = {
+  SIGSEGV, SIGABRT, SIGFPE, SIGILL, SIGBUS
 };
+const int kNumHandledSignals =
+    sizeof(kExceptionSignals) / sizeof(kExceptionSignals[0]);
+struct sigaction old_handlers[kNumHandledSignals];
+bool handlers_installed = false;
+
+// InstallAlternateStackLocked will store the newly installed stack in new_stack
+// and (if it exists) the previously installed stack in old_stack.
+stack_t old_stack;
+stack_t new_stack;
+bool stack_installed = false;
+
+// Create an alternative stack to run the signal handlers on. This is done since
+// the signal might have been caused by a stack overflow.
+// Runs before crashing: normal context.
+void InstallAlternateStackLocked() {
+  if (stack_installed)
+    return;
+
+  memset(&old_stack, 0, sizeof(old_stack));
+  memset(&new_stack, 0, sizeof(new_stack));
+
+  // SIGSTKSZ may be too small to prevent the signal handlers from overrunning
+  // the alternative stack. Ensure that the size of the alternative stack is
+  // large enough.
+  static const unsigned kSigStackSize = std::max(8192, SIGSTKSZ);
+
+  // Only set an alternative stack if there isn't already one, or if the current
+  // one is too small.
+  if (sys_sigaltstack(NULL, &old_stack) == -1 || !old_stack.ss_sp ||
+      old_stack.ss_size < kSigStackSize) {
+    new_stack.ss_sp = malloc(kSigStackSize);
+    new_stack.ss_size = kSigStackSize;
+
+    if (sys_sigaltstack(&new_stack, NULL) == -1) {
+      free(new_stack.ss_sp);
+      return;
+    }
+    stack_installed = true;
+  }
+}
+
+// Runs before crashing: normal context.
+void RestoreAlternateStackLocked() {
+  if (!stack_installed)
+    return;
+
+  stack_t current_stack;
+  if (sys_sigaltstack(NULL, &current_stack) == -1)
+    return;
+
+  // Only restore the old_stack if the current alternative stack is the one
+  // installed by the call to InstallAlternateStackLocked.
+  if (current_stack.ss_sp == new_stack.ss_sp) {
+    if (old_stack.ss_sp) {
+      if (sys_sigaltstack(&old_stack, NULL) == -1)
+        return;
+    } else {
+      stack_t disable_stack;
+      disable_stack.ss_flags = SS_DISABLE;
+      if (sys_sigaltstack(&disable_stack, NULL) == -1)
+        return;
+    }
+  }
+
+  free(new_stack.ss_sp);
+  stack_installed = false;
+}
+
+}  // namespace
 
 // We can stack multiple exception handlers. In that case, this is the global
 // which holds the stack.
 std::vector<ExceptionHandler*>* ExceptionHandler::handler_stack_ = NULL;
-unsigned ExceptionHandler::handler_stack_index_ = 0;
 pthread_mutex_t ExceptionHandler::handler_stack_mutex_ =
     PTHREAD_MUTEX_INITIALIZER;
 
 // Runs before crashing: normal context.
-ExceptionHandler::ExceptionHandler(const std::string &dump_path,
-                                   FilterCallback filter,
-                                   MinidumpCallback callback,
-                                   void *callback_context,
-                                   bool install_handler)
-  : filter_(filter),
-    callback_(callback),
-    callback_context_(callback_context),
-    handler_installed_(install_handler)
-{
-  Init(dump_path, -1);
-}
-
-ExceptionHandler::ExceptionHandler(const std::string &dump_path,
+ExceptionHandler::ExceptionHandler(const MinidumpDescriptor& descriptor,
                                    FilterCallback filter,
                                    MinidumpCallback callback,
                                    void* callback_context,
                                    bool install_handler,
                                    const int server_fd)
-  : filter_(filter),
-    callback_(callback),
-    callback_context_(callback_context),
-    handler_installed_(install_handler)
-{
-  Init(dump_path, server_fd);
-}
+    : filter_(filter),
+      callback_(callback),
+      callback_context_(callback_context),
+      minidump_descriptor_(descriptor),
+      crash_handler_(NULL) {
+  if (server_fd >= 0)
+    crash_generation_client_.reset(CrashGenerationClient::TryCreate(server_fd));
 
-// Runs before crashing: normal context.
-ExceptionHandler::~ExceptionHandler() {
-  UninstallHandlers();
-}
-
-void ExceptionHandler::Init(const std::string &dump_path,
-                            const int server_fd)
-{
-  crash_handler_ = NULL;
-  if (0 <= server_fd)
-    crash_generation_client_
-      .reset(CrashGenerationClient::TryCreate(server_fd));
-
-  if (handler_installed_)
-    InstallHandlers();
-
-  if (!IsOutOfProcess())
-    set_dump_path(dump_path);
+  if (!IsOutOfProcess() && !minidump_descriptor_.IsFD())
+    minidump_descriptor_.UpdatePath();
 
   pthread_mutex_lock(&handler_stack_mutex_);
-  if (handler_stack_ == NULL)
-    handler_stack_ = new std::vector<ExceptionHandler *>;
+  if (!handler_stack_)
+    handler_stack_ = new std::vector<ExceptionHandler*>;
+  if (install_handler) {
+    InstallAlternateStackLocked();
+    InstallHandlersLocked();
+  }
   handler_stack_->push_back(this);
   pthread_mutex_unlock(&handler_stack_mutex_);
 }
 
 // Runs before crashing: normal context.
-bool ExceptionHandler::InstallHandlers() {
-  // We run the signal handlers on an alternative stack because we might have
-  // crashed because of a stack overflow.
+ExceptionHandler::~ExceptionHandler() {
+  pthread_mutex_lock(&handler_stack_mutex_);
+  std::vector<ExceptionHandler*>::iterator handler =
+      std::find(handler_stack_->begin(), handler_stack_->end(), this);
+  handler_stack_->erase(handler);
+  if (handler_stack_->empty()) {
+    RestoreAlternateStackLocked();
+    RestoreHandlersLocked();
+  }
+  pthread_mutex_unlock(&handler_stack_mutex_);
+}
 
-  // We use this value rather than SIGSTKSZ because we would end up overrunning
-  // such a small stack.
-  static const unsigned kSigStackSize = 8192;
+// Runs before crashing: normal context.
+// static
+bool ExceptionHandler::InstallHandlersLocked() {
+  if (handlers_installed)
+    return false;
 
-  stack_t stack;
-  // Only set an alternative stack if there isn't already one, or if the current
-  // one is too small.
-  if (sys_sigaltstack(NULL, &stack) == -1 || !stack.ss_sp ||
-      stack.ss_size < kSigStackSize) {
-    memset(&stack, 0, sizeof(stack));
-    stack.ss_sp = malloc(kSigStackSize);
-    stack.ss_size = kSigStackSize;
-
-    if (sys_sigaltstack(&stack, NULL) == -1)
+  // Fail if unable to store all the old handlers.
+  for (unsigned i = 0; i < kNumHandledSignals; ++i) {
+    if (sigaction(kExceptionSignals[i], NULL, &old_handlers[i]) == -1)
       return false;
   }
 
@@ -207,54 +249,36 @@ bool ExceptionHandler::InstallHandlers() {
   memset(&sa, 0, sizeof(sa));
   sigemptyset(&sa.sa_mask);
 
-  // mask all exception signals when we're handling one of them.
-  for (unsigned i = 0; kExceptionSignals[i] != -1; ++i)
+  // Mask all exception signals when we're handling one of them.
+  for (unsigned i = 0; i < kNumHandledSignals; ++i)
     sigaddset(&sa.sa_mask, kExceptionSignals[i]);
 
   sa.sa_sigaction = SignalHandler;
   sa.sa_flags = SA_ONSTACK | SA_SIGINFO;
 
-  for (unsigned i = 0; kExceptionSignals[i] != -1; ++i) {
-    struct sigaction* old = new struct sigaction;
-    if (sigaction(kExceptionSignals[i], &sa, old) == -1)
-      return false;
-    old_handlers_.push_back(std::make_pair(kExceptionSignals[i], old));
+  for (unsigned i = 0; i < kNumHandledSignals; ++i) {
+    if (sigaction(kExceptionSignals[i], &sa, NULL) == -1) {
+      // At this point it is impractical to back out changes, and so failure to
+      // install a signal is intentionally ignored.
+    }
   }
+  handlers_installed = true;
   return true;
 }
 
-// Runs before crashing: normal context.
-void ExceptionHandler::UninstallHandlers() {
-  for (unsigned i = 0; i < old_handlers_.size(); ++i) {
-    struct sigaction *action =
-        reinterpret_cast<struct sigaction*>(old_handlers_[i].second);
-    sigaction(old_handlers_[i].first, action, NULL);
-    delete action;
-  }
-  pthread_mutex_lock(&handler_stack_mutex_);
-  std::vector<ExceptionHandler*>::iterator handler =
-      std::find(handler_stack_->begin(), handler_stack_->end(), this);
-  handler_stack_->erase(handler);
-  pthread_mutex_unlock(&handler_stack_mutex_);
-  old_handlers_.clear();
-}
-
-// Runs before crashing: normal context.
-void ExceptionHandler::UpdateNextID() {
-  GUID guid;
-  char guid_str[kGUIDStringLength + 1];
-  if (CreateGUID(&guid) && GUIDToString(&guid, guid_str, sizeof(guid_str))) {
-    next_minidump_id_ = guid_str;
-    next_minidump_id_c_ = next_minidump_id_.c_str();
-
-    char minidump_path[PATH_MAX];
-    snprintf(minidump_path, sizeof(minidump_path), "%s/%s.dmp",
-             dump_path_c_,
-             guid_str);
-
-    next_minidump_path_ = minidump_path;
-    next_minidump_path_c_ = next_minidump_path_.c_str();
+// This function runs in a compromised context: see the top of the file.
+// Runs on the crashing thread.
+// static
+void ExceptionHandler::RestoreHandlersLocked() {
+  if (!handlers_installed)
+    return;
+
+  for (unsigned i = 0; i < kNumHandledSignals; ++i) {
+    if (sigaction(kExceptionSignals[i], &old_handlers[i], NULL) == -1) {
+      signal(kExceptionSignals[i], SIG_DFL);
+    }
   }
+  handlers_installed = false;
 }
 
 // void ExceptionHandler::set_crash_handler(HandlerCallback callback) {
@@ -268,36 +292,44 @@ void ExceptionHandler::SignalHandler(int sig, siginfo_t* info, void* uc) {
   // All the exception signals are blocked at this point.
   pthread_mutex_lock(&handler_stack_mutex_);
 
-  if (!handler_stack_->size()) {
-    pthread_mutex_unlock(&handler_stack_mutex_);
-    return;
+  bool handled = false;
+  for (int i = handler_stack_->size() - 1; !handled && i >= 0; --i) {
+    handled = (*handler_stack_)[i]->HandleSignal(sig, info, uc);
   }
 
-  for (int i = handler_stack_->size() - 1; i >= 0; --i) {
-    if ((*handler_stack_)[i]->HandleSignal(sig, info, uc)) {
-      // successfully handled: We are in an invalid state since an exception
-      // signal has been delivered. We don't call the exit handlers because
-      // they could end up corrupting on-disk state.
-      break;
-    }
+  // Upon returning from this signal handler, sig will become unmasked and then
+  // it will be retriggered. If one of the ExceptionHandlers handled it
+  // successfully, restore the default handler. Otherwise, restore the
+  // previously installed handler. Then, when the signal is retriggered, it will
+  // be delivered to the appropriate handler.
+  if (handled) {
+    signal(sig, SIG_DFL);
+  } else {
+    RestoreHandlersLocked();
   }
 
   pthread_mutex_unlock(&handler_stack_mutex_);
 
-  // Terminate ourselves with the same signal so that our parent knows that we
-  // crashed. The default action for all the signals which we catch is Core, so
-  // this is the end of us.
-  signal(sig, SIG_DFL);
-
-  // TODO(markus): mask signal and return to caller
-  tgkill(getpid(), syscall(__NR_gettid), sig);
-  _exit(1);
-
-  // not reached.
+  if (info->si_pid) {
+    // This signal was triggered by somebody sending us the signal with kill().
+    // In order to retrigger it, we have to queue a new signal by calling
+    // kill() ourselves.
+    if (tgkill(getpid(), syscall(__NR_gettid), sig) < 0) {
+      // If we failed to kill ourselves (e.g. because a sandbox disallows us
+      // to do so), we instead resort to terminating our process. This will
+      // result in an incorrect exit code.
+      _exit(1);
+    }
+  } else {
+    // This was a synchronous signal triggered by a hard fault (e.g. SIGSEGV).
+    // No need to reissue the signal. It will automatically trigger again,
+    // when we return from the signal handler.
+  }
 }
 
 struct ThreadArgument {
   pid_t pid;  // the crashing process
+  const MinidumpDescriptor* minidump_descriptor;
   ExceptionHandler* handler;
   const void* context;  // a CrashContext structure
   size_t context_size;
@@ -323,8 +355,13 @@ bool ExceptionHandler::HandleSignal(int sig, siginfo_t* info, void* uc) {
   if (filter_ && !filter_(callback_context_))
     return false;
 
-  // Allow ourselves to be dumped.
-  sys_prctl(PR_SET_DUMPABLE, 1);
+  // Allow ourselves to be dumped if the signal is trusted.
+  bool signal_trusted = info->si_code > 0;
+  bool signal_pid_trusted = info->si_code == SI_USER ||
+      info->si_code == SI_TKILL;
+  if (signal_trusted || (signal_pid_trusted && info->si_pid == getpid())) {
+    sys_prctl(PR_SET_DUMPABLE, 1);
+  }
   CrashContext context;
   memcpy(&context.siginfo, info, sizeof(siginfo_t));
   memcpy(&context.context, uc, sizeof(struct ucontext));
@@ -339,14 +376,23 @@ bool ExceptionHandler::HandleSignal(int sig, siginfo_t* info, void* uc) {
 #endif
   context.tid = syscall(__NR_gettid);
   if (crash_handler_ != NULL) {
-    if (crash_handler_(&context, sizeof(context),
-                       callback_context_)) {
+    if (crash_handler_(&context, sizeof(context), callback_context_)) {
       return true;
     }
   }
   return GenerateDump(&context);
 }
 
+// This is a public interface to HandleSignal that allows the client to
+// generate a crash dump. This function may run in a compromised context.
+bool ExceptionHandler::SimulateSignalDelivery(int sig) {
+  siginfo_t siginfo;
+  my_memset(&siginfo, 0, sizeof(siginfo_t));
+  struct ucontext context;
+  getcontext(&context);
+  return HandleSignal(sig, &siginfo, &context);
+}
+
 // This function may run in a compromised context: see the top of the file.
 bool ExceptionHandler::GenerateDump(CrashContext *context) {
   if (IsOutOfProcess())
@@ -363,6 +409,7 @@ bool ExceptionHandler::GenerateDump(CrashContext *context) {
 
   ThreadArgument thread_arg;
   thread_arg.handler = this;
+  thread_arg.minidump_descriptor = &minidump_descriptor_;
   thread_arg.pid = getpid();
   thread_arg.context = context;
   thread_arg.context_size = sizeof(*context);
@@ -377,17 +424,18 @@ bool ExceptionHandler::GenerateDump(CrashContext *context) {
     // is the write() and read() calls will fail with EBADF
     static const char no_pipe_msg[] = "ExceptionHandler::GenerateDump \
                                        sys_pipe failed:";
-    sys_write(2, no_pipe_msg, sizeof(no_pipe_msg) - 1);
-    sys_write(2, strerror(errno), strlen(strerror(errno)));
-    sys_write(2, "\n", 1);
+    logger::write(no_pipe_msg, sizeof(no_pipe_msg) - 1);
+    logger::write(strerror(errno), strlen(strerror(errno)));
+    logger::write("\n", 1);
   }
 
   const pid_t child = sys_clone(
       ThreadEntry, stack, CLONE_FILES | CLONE_FS | CLONE_UNTRACED,
       &thread_arg, NULL, NULL, NULL);
+
   int r, status;
   // Allow the child to ptrace us
-  prctl(PR_SET_PTRACER, child, 0, 0, 0);
+  sys_prctl(PR_SET_PTRACER, child);
   SendContinueSignalToChild();
   do {
     r = sys_waitpid(child, &status, __WALL);
@@ -398,17 +446,14 @@ bool ExceptionHandler::GenerateDump(CrashContext *context) {
 
   if (r == -1) {
     static const char msg[] = "ExceptionHandler::GenerateDump waitpid failed:";
-    sys_write(2, msg, sizeof(msg) - 1);
-    sys_write(2, strerror(errno), strlen(strerror(errno)));
-    sys_write(2, "\n", 1);
+    logger::write(msg, sizeof(msg) - 1);
+    logger::write(strerror(errno), strlen(strerror(errno)));
+    logger::write("\n", 1);
   }
 
   bool success = r != -1 && WIFEXITED(status) && WEXITSTATUS(status) == 0;
-
   if (callback_)
-    success = callback_(dump_path_c_, next_minidump_id_c_,
-                        callback_context_, success);
-
+    success = callback_(minidump_descriptor_, callback_context_, success);
   return success;
 }
 
@@ -420,9 +465,9 @@ void ExceptionHandler::SendContinueSignalToChild() {
   if(r == -1) {
     static const char msg[] = "ExceptionHandler::SendContinueSignalToChild \
                                sys_write failed:";
-    sys_write(2, msg, sizeof(msg) - 1);
-    sys_write(2, strerror(errno), strlen(strerror(errno)));
-    sys_write(2, "\n", 1);
+    logger::write(msg, sizeof(msg) - 1);
+    logger::write(strerror(errno), strlen(strerror(errno)));
+    logger::write("\n", 1);
   }
 }
 
@@ -435,9 +480,9 @@ void ExceptionHandler::WaitForContinueSignal() {
   if(r == -1) {
     static const char msg[] = "ExceptionHandler::WaitForContinueSignal \
                                sys_read failed:";
-    sys_write(2, msg, sizeof(msg) - 1);
-    sys_write(2, strerror(errno), strlen(strerror(errno)));
-    sys_write(2, "\n", 1);
+    logger::write(msg, sizeof(msg) - 1);
+    logger::write(strerror(errno), strlen(strerror(errno)));
+    logger::write("\n", 1);
   }
 }
 
@@ -445,118 +490,133 @@ void ExceptionHandler::WaitForContinueSignal() {
 // Runs on the cloned process.
 bool ExceptionHandler::DoDump(pid_t crashing_process, const void* context,
                               size_t context_size) {
-  return google_breakpad::WriteMinidump(next_minidump_path_c_,
+  if (minidump_descriptor_.IsFD()) {
+    return google_breakpad::WriteMinidump(minidump_descriptor_.fd(),
+                                          crashing_process,
+                                          context,
+                                          context_size,
+                                          mapping_list_,
+                                          app_memory_list_);
+  }
+  return google_breakpad::WriteMinidump(minidump_descriptor_.path(),
                                         crashing_process,
                                         context,
                                         context_size,
-                                        mapping_info_,
-                                        app_memory_info_);
+                                        mapping_list_,
+                                        app_memory_list_);
 }
 
 // static
-bool ExceptionHandler::WriteMinidump(const std::string &dump_path,
+bool ExceptionHandler::WriteMinidump(const string& dump_path,
                                      MinidumpCallback callback,
                                      void* callback_context) {
-  return WriteMinidump(dump_path, false, callback, callback_context);
-}
-
-// static
-bool ExceptionHandler::WriteMinidump(const std::string &dump_path,
-                                     bool write_exception_stream,
-                                     MinidumpCallback callback,
-                                     void* callback_context) {
-  ExceptionHandler eh(dump_path, NULL, callback, callback_context, false);
-  return eh.WriteMinidump(write_exception_stream);
+  MinidumpDescriptor descriptor(dump_path);
+  ExceptionHandler eh(descriptor, NULL, callback, callback_context, false, -1);
+  return eh.WriteMinidump();
 }
 
 bool ExceptionHandler::WriteMinidump() {
-  return WriteMinidump(false);
-}
+  if (!IsOutOfProcess() && !minidump_descriptor_.IsFD()) {
+    // Update the path of the minidump so that this can be called multiple times
+    // and new files are created for each minidump.  This is done before the
+    // generation happens, as clients may want to access the MinidumpDescriptor
+    // after this call to find the exact path to the minidump file.
+    minidump_descriptor_.UpdatePath();
+  } else if (minidump_descriptor_.IsFD()) {
+    // Reposition the FD to its beginning and resize it to get rid of the
+    // previous minidump info.
+    lseek(minidump_descriptor_.fd(), 0, SEEK_SET);
+    static_cast<void>(ftruncate(minidump_descriptor_.fd(), 0));
+  }
 
-bool ExceptionHandler::WriteMinidump(bool write_exception_stream) {
-#if !defined(__ARM_EABI__)
-  // Allow ourselves to be dumped.
+  // Allow this process to be dumped.
   sys_prctl(PR_SET_DUMPABLE, 1);
 
   CrashContext context;
   int getcontext_result = getcontext(&context.context);
   if (getcontext_result)
     return false;
+#if !defined(__ARM_EABI__)
+  // FPU state is not part of ARM EABI ucontext_t.
   memcpy(&context.float_state, context.context.uc_mcontext.fpregs,
          sizeof(context.float_state));
+#endif
   context.tid = sys_gettid();
 
-  if (write_exception_stream) {
-    memset(&context.siginfo, 0, sizeof(context.siginfo));
-    context.siginfo.si_signo = SIGSTOP;
-#if defined(__i386)
-    context.siginfo.si_addr =
+  // Add an exception stream to the minidump for better reporting.
+  memset(&context.siginfo, 0, sizeof(context.siginfo));
+  context.siginfo.si_signo = MD_EXCEPTION_CODE_LIN_DUMP_REQUESTED;
+#if defined(__i386__)
+  context.siginfo.si_addr =
       reinterpret_cast<void*>(context.context.uc_mcontext.gregs[REG_EIP]);
-#elif defined(__x86_64)
-    context.siginfo.si_addr =
+#elif defined(__x86_64__)
+  context.siginfo.si_addr =
       reinterpret_cast<void*>(context.context.uc_mcontext.gregs[REG_RIP]);
-#elif defined(__ARMEL__)
-    context.siginfo.si_addr =
-      reinterpret_cast<void*>(context.context.uc_mcontext.arm_ip);
+#elif defined(__arm__)
+  context.siginfo.si_addr =
+      reinterpret_cast<void*>(context.context.uc_mcontext.arm_pc);
+#else
+#error "This code has not been ported to your platform yet."
 #endif
+
+  return GenerateDump(&context);
+}
+
+void ExceptionHandler::AddMappingInfo(const string& name,
+                                      const u_int8_t identifier[sizeof(MDGUID)],
+                                      uintptr_t start_address,
+                                      size_t mapping_size,
+                                      size_t file_offset) {
+  MappingInfo info;
+  info.start_addr = start_address;
+  info.size = mapping_size;
+  info.offset = file_offset;
+  strncpy(info.name, name.c_str(), sizeof(info.name) - 1);
+  info.name[sizeof(info.name) - 1] = '\0';
+
+  MappingEntry mapping;
+  mapping.first = info;
+  memcpy(mapping.second, identifier, sizeof(MDGUID));
+  mapping_list_.push_back(mapping);
+}
+
+void ExceptionHandler::RegisterAppMemory(void* ptr, size_t length) {
+  AppMemoryList::iterator iter =
+    std::find(app_memory_list_.begin(), app_memory_list_.end(), ptr);
+  if (iter != app_memory_list_.end()) {
+    // Don't allow registering the same pointer twice.
+    return;
   }
 
-  bool success = GenerateDump(&context);
-  UpdateNextID();
-  return success;
-#else
-  return false;
-#endif  // !defined(__ARM_EABI__)
+  AppMemory app_memory;
+  app_memory.ptr = ptr;
+  app_memory.length = length;
+  app_memory_list_.push_back(app_memory);
+}
+
+void ExceptionHandler::UnregisterAppMemory(void* ptr) {
+  AppMemoryList::iterator iter =
+    std::find(app_memory_list_.begin(), app_memory_list_.end(), ptr);
+  if (iter != app_memory_list_.end()) {
+    app_memory_list_.erase(iter);
+  }
 }
 
 // static
 bool ExceptionHandler::WriteMinidumpForChild(pid_t child,
                                              pid_t child_blamed_thread,
-                                             const std::string &dump_path,
+                                             const string& dump_path,
                                              MinidumpCallback callback,
-                                             void *callback_context)
-{
+                                             void* callback_context) {
   // This function is not run in a compromised context.
-  ExceptionHandler eh(dump_path, NULL, NULL, NULL, false);
-  if (!google_breakpad::WriteMinidump(eh.next_minidump_path_c_,
+  MinidumpDescriptor descriptor(dump_path);
+  descriptor.UpdatePath();
+  if (!google_breakpad::WriteMinidump(descriptor.path(),
                                       child,
                                       child_blamed_thread))
       return false;
 
-  return callback ? callback(eh.dump_path_c_, eh.next_minidump_id_c_,
-                             callback_context, true) : true;
-}
-
-void ExceptionHandler::AddMappingInfo(const std::string& name,
-                                      const u_int8_t identifier[sizeof(MDGUID)],
-                                      uintptr_t start_address,
-                                      size_t mapping_size,
-                                      size_t file_offset) {
-   MappingInfo info;
-   info.start_addr = start_address;
-   info.size = mapping_size;
-   info.offset = file_offset;
-   strncpy(info.name, name.c_str(), std::min(name.size() + 1, sizeof(info)));
- 
-   std::pair<MappingInfo, u_int8_t[sizeof(MDGUID)]> mapping;
-   mapping.first = info;
-   memcpy(mapping.second, identifier, sizeof(MDGUID));
-   mapping_info_.push_back(mapping);
-}
-
-void ExceptionHandler::RegisterAppMemory(void *ptr, size_t length) {
-  app_memory_info_.push_back(AppMemory(ptr, length));
-}
-
-void ExceptionHandler::UnregisterAppMemory(void *ptr) {
-  for (AppMemoryList::iterator iter = app_memory_info_.begin();
-       iter != app_memory_info_.end();
-       ++iter) {
-    if (iter->ptr == ptr) {
-      app_memory_info_.erase(iter);
-      return;
-    }
-  }
+  return callback ? callback(descriptor, callback_context, true) : true;
 }
 
 }  // namespace google_breakpad

toolkit/crashreporter/google-breakpad/src/client/linux/handler/exception_handler.h

@@ -37,19 +37,17 @@
 #include <signal.h>
 #include <stdint.h>
 #include <stdio.h>
+#include <sys/ucontext.h>
 
-#include "client/linux/android_ucontext.h"
 #include "client/linux/crash_generation/crash_generation_client.h"
+#include "client/linux/handler/minidump_descriptor.h"
 #include "client/linux/minidump_writer/minidump_writer.h"
+#include "common/using_std_string.h"
 #include "google_breakpad/common/minidump_format.h"
 #include "processor/scoped_ptr.h"
 
-struct sigaction;
-
 namespace google_breakpad {
 
-class ExceptionHandler;
-
 // ExceptionHandler
 //
 // ExceptionHandler can write a minidump file when an exception occurs,
@@ -68,17 +66,18 @@ class ExceptionHandler;
 // use different minidump callbacks for different call sites.
 //
 // In either case, a callback function is called when a minidump is written,
-// which receives the unqiue id of the minidump.  The caller can use this
-// id to collect and write additional application state, and to launch an
-// external crash-reporting application.
+// which receives the full path or file descriptor of the minidump.  The
+// caller can collect and write additional application state to that minidump,
+// and launch an external crash-reporting application.
 //
 // Caller should try to make the callbacks as crash-friendly as possible,
 // it should avoid use heap memory allocation as much as possible.
+
 class ExceptionHandler {
  public:
   // A callback function to run before Breakpad performs any substantial
   // processing of an exception.  A FilterCallback is called before writing
-  // a minidump.  context is the parameter supplied by the user as
+  // a minidump.  |context| is the parameter supplied by the user as
   // callback_context when the handler was created.
   //
   // If a FilterCallback returns true, Breakpad will continue processing,
@@ -88,10 +87,10 @@ class ExceptionHandler {
   typedef bool (*FilterCallback)(void *context);
 
   // A callback function to run after the minidump has been written.
-  // minidump_id is a unique id for the dump, so the minidump
-  // file is <dump_path>\<minidump_id>.dmp.  context is the parameter supplied
-  // by the user as callback_context when the handler was created.  succeeded
-  // indicates whether a minidump file was successfully written.
+  // |descriptor| contains the file descriptor or file path containing the
+  // minidump. |context| is the parameter supplied by the user as
+  // callback_context when the handler was created.  |succeeded| indicates
+  // whether a minidump file was successfully written.
   //
   // If an exception occurred and the callback returns true, Breakpad will
   // treat the exception as fully-handled, suppressing any other handlers from
@@ -103,14 +102,13 @@ class ExceptionHandler {
   // should normally return the value of |succeeded|, or when they wish to
   // not report an exception of handled, false.  Callbacks will rarely want to
   // return true directly (unless |succeeded| is true).
-  typedef bool (*MinidumpCallback)(const char *dump_path,
-                                   const char *minidump_id,
-                                   void *context,
+  typedef bool (*MinidumpCallback)(const MinidumpDescriptor& descriptor,
+                                   void* context,
                                    bool succeeded);
 
   // In certain cases, a user may wish to handle the generation of the minidump
   // themselves. In this case, they can install a handler callback which is
-  // called when a crash has occured. If this function returns true, no other
+  // called when a crash has occurred. If this function returns true, no other
   // processing of occurs and the process will shortly be crashed. If this
   // returns false, the normal processing continues.
   typedef bool (*HandlerCallback)(const void* crash_context,
@@ -118,61 +116,54 @@ class ExceptionHandler {
                                   void* context);
 
   // Creates a new ExceptionHandler instance to handle writing minidumps.
-  // Before writing a minidump, the optional filter callback will be called.
+  // Before writing a minidump, the optional |filter| callback will be called.
   // Its return value determines whether or not Breakpad should write a
-  // minidump.  Minidump files will be written to dump_path, and the optional
-  // callback is called after writing the dump file, as described above.
+  // minidump.  The minidump content will be written to the file path or file
+  // descriptor from |descriptor|, and the optional |callback| is called after
+  // writing the dump file, as described above.
   // If install_handler is true, then a minidump will be written whenever
   // an unhandled exception occurs.  If it is false, minidumps will only
   // be written when WriteMinidump is called.
-  ExceptionHandler(const std::string &dump_path,
-                   FilterCallback filter, MinidumpCallback callback,
+  // If |server_fd| is valid, the minidump is generated out-of-process.  If it
+  // is -1, in-process generation will always be used.
+  ExceptionHandler(const MinidumpDescriptor& descriptor,
+                   FilterCallback filter,
+                   MinidumpCallback callback,
                    void *callback_context,
-                   bool install_handler);
-
-  // Creates a new ExceptionHandler instance that can attempt to
-  // perform out-of-process dump generation if server_fd is valid. If
-  // server_fd is invalid, in-process dump generation will be
-  // used. See the above ctor for a description of the other
-  // parameters.
-  ExceptionHandler(const std::string& dump_path,
-                   FilterCallback filter, MinidumpCallback callback,
-                   void* callback_context,
                    bool install_handler,
                    const int server_fd);
-
   ~ExceptionHandler();
 
-  // Get and set the minidump path.
-  std::string dump_path() const { return dump_path_; }
-  void set_dump_path(const std::string &dump_path) {
-    dump_path_ = dump_path;
-    dump_path_c_ = dump_path_.c_str();
-    UpdateNextID();
+  const MinidumpDescriptor& minidump_descriptor() const {
+    return minidump_descriptor_;
+  }
+
+  void set_minidump_descriptor(const MinidumpDescriptor& descriptor) {
+    minidump_descriptor_ = descriptor;
   }
 
   void set_crash_handler(HandlerCallback callback) {
     crash_handler_ = callback;
   }
 
-  // Writes a minidump immediately.  This can be used to capture the
-  // execution state independently of a crash.  Returns true on success.
+  // Writes a minidump immediately.  This can be used to capture the execution
+  // state independently of a crash.
+  // Returns true on success.
+  // If the ExceptionHandler has been created with a path, a new file is
+  // generated for each minidump.  The file path can be retrieved in the
+  // MinidumpDescriptor passed to the MinidumpCallback or by accessing the
+  // MinidumpDescriptor directly from the ExceptionHandler (with
+  // minidump_descriptor()).
+  // If the ExceptionHandler has been created with a file descriptor, the file
+  // descriptor is repositioned to its beginning and the previous generated
+  // minidump is overwritten.
+  // Note that this method is not supposed to be called from a compromised
+  // context as it uses the heap.
   bool WriteMinidump();
 
-  // Variant of WriteMinidump() above that optionally allows writing
-  // an artificial exception stream in the minidump.
-  bool WriteMinidump(bool write_exception_stream);
-
   // Convenience form of WriteMinidump which does not require an
   // ExceptionHandler instance.
-  static bool WriteMinidump(const std::string &dump_path,
-                            MinidumpCallback callback,
-                            void *callback_context);
-
-  // Variant of WriteMinidump() above that optionally allows writing
-  // an artificial exception stream in the minidump.
-  static bool WriteMinidump(const std::string &dump_path,
-                            bool write_exception_stream,
+  static bool WriteMinidump(const string& dump_path,
                             MinidumpCallback callback,
                             void* callback_context);
 
@@ -182,16 +173,16 @@ class ExceptionHandler {
   // the child process the one from which a crash signature is
   // extracted.
   //
-  // WARNING: the return of this function *must* be ordered
-  // happens-before the code that will eventually reap |child|.
+  // WARNING: the return of this function *must* happen before
+  // the code that will eventually reap |child| executes.
   // Otherwise there's a pernicious race condition in which |child|
   // exits, is reaped, another process created with its pid, then that
   // new process dumped.
   static bool WriteMinidumpForChild(pid_t child,
                                     pid_t child_blamed_thread,
-                                    const std::string &dump_path,
+                                    const string& dump_path,
                                     MinidumpCallback callback,
-                                    void *callback_context);
+                                    void* callback_context);
 
   // This structure is passed to minidump_writer.h:WriteMinidump via an opaque
   // blob. It shouldn't be needed in any user code.
@@ -213,28 +204,32 @@ class ExceptionHandler {
   // Add information about a memory mapping. This can be used if
   // a custom library loader is used that maps things in a way
   // that the linux dumper can't handle by reading the maps file.
-  void AddMappingInfo(const std::string& name,
+  void AddMappingInfo(const string& name,
                       const u_int8_t identifier[sizeof(MDGUID)],
                       uintptr_t start_address,
                       size_t mapping_size,
                       size_t file_offset);
 
-  // Calling RegisterAppMemory(p, len) causes len bytes starting
-  // at address p to be copied to the minidump when a crash happens.
-  void RegisterAppMemory(void *ptr, size_t length);
-  void UnregisterAppMemory(void *ptr);
+  // Register a block of memory of length bytes starting at address ptr
+  // to be copied to the minidump when a crash happens.
+  void RegisterAppMemory(void* ptr, size_t length);
 
+  // Unregister a block of memory that was registered with RegisterAppMemory.
+  void UnregisterAppMemory(void* ptr);
+
+  // Force signal handling for the specified signal.
+  bool SimulateSignalDelivery(int sig);
  private:
-  void Init(const std::string &dump_path,
-            const int server_fd);
-  bool InstallHandlers();
-  void UninstallHandlers();
+  // Save the old signal handlers and install new ones.
+  static bool InstallHandlersLocked();
+  // Restore the old signal handlers.
+  static void RestoreHandlersLocked();
+
   void PreresolveSymbols();
   bool GenerateDump(CrashContext *context);
   void SendContinueSignalToChild();
   void WaitForContinueSignal();
 
-  void UpdateNextID();
   static void SignalHandler(int sig, siginfo_t* info, void* uc);
   bool HandleSignal(int sig, siginfo_t* info, void* uc);
   static int ThreadEntry(void* arg);
@@ -247,31 +242,16 @@ class ExceptionHandler {
 
   scoped_ptr<CrashGenerationClient> crash_generation_client_;
 
-  std::string dump_path_;
-  std::string next_minidump_path_;
-  std::string next_minidump_id_;
+  MinidumpDescriptor minidump_descriptor_;
 
-  // Pointers to C-string representations of the above. These are set
-  // when the above are set so we can avoid calling c_str during
-  // an exception.
-  const char* dump_path_c_;
-  const char* next_minidump_path_c_;
-  const char* next_minidump_id_c_;
-
-  const bool handler_installed_;
   HandlerCallback crash_handler_;
 
   // The global exception handler stack. This is need becuase there may exist
   // multiple ExceptionHandler instances in a process. Each will have itself
   // registered in this stack.
   static std::vector<ExceptionHandler*> *handler_stack_;
-  // The index of the handler that should handle the next exception.
-  static unsigned handler_stack_index_;
   static pthread_mutex_t handler_stack_mutex_;
 
-  // A vector of the old signal handlers.
-  std::vector<std::pair<int, struct sigaction *> > old_handlers_;
-
   // We need to explicitly enable ptrace of parent processes on some
   // kernels, but we need to know the PID of the cloned process before we
   // can do this. We create a pipe which we can use to block the
@@ -281,11 +261,11 @@ class ExceptionHandler {
 
   // Callers can add extra info about mappings for cases where the
   // dumper code cannot extract enough information from /proc/<pid>/maps.
-  MappingList mapping_info_;
+  MappingList mapping_list_;
 
   // Callers can request additional memory regions to be included in
   // the dump.
-  AppMemoryList app_memory_info_;
+  AppMemoryList app_memory_list_;
 };
 
 }  // namespace google_breakpad

toolkit/crashreporter/google-breakpad/src/client/linux/handler/minidump_descriptor.cc

@@ -0,0 +1,76 @@
+// Copyright (c) 2012 Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#include <stdio.h>
+
+#include "client/linux/handler/minidump_descriptor.h"
+
+#include "common/linux/guid_creator.h"
+
+namespace google_breakpad {
+
+MinidumpDescriptor::MinidumpDescriptor(const MinidumpDescriptor& descriptor)
+    : fd_(descriptor.fd_),
+      directory_(descriptor.directory_),
+      c_path_(NULL) {
+  // The copy constructor is not allowed to be called on a MinidumpDescriptor
+  // with a valid path_, as getting its c_path_ would require the heap which
+  // can cause problems in compromised environments.
+  assert(descriptor.path_.empty());
+}
+
+MinidumpDescriptor& MinidumpDescriptor::operator=(
+    const MinidumpDescriptor& descriptor) {
+  assert(descriptor.path_.empty());
+
+  fd_ = descriptor.fd_;
+  directory_ = descriptor.directory_;
+  path_.clear();
+  if (c_path_) {
+    // This descriptor already had a path set, so generate a new one.
+    c_path_ = NULL;
+    UpdatePath();
+  }
+  return *this;
+}
+
+void MinidumpDescriptor::UpdatePath() {
+  assert(fd_ == -1 && !directory_.empty());
+
+  GUID guid;
+  char guid_str[kGUIDStringLength + 1];
+  bool r = CreateGUID(&guid) && GUIDToString(&guid, guid_str, sizeof(guid_str));
+  assert(r);
+
+  path_.clear();
+  path_ = directory_ + "/" + guid_str + ".dmp";  
+  c_path_ = path_.c_str();
+}
+
+}  // namespace google_breakpad

toolkit/crashreporter/google-breakpad/src/client/linux/handler/minidump_descriptor.h

@@ -0,0 +1,89 @@
+// Copyright (c) 2012 Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef CLIENT_LINUX_HANDLER_MINIDUMP_DESCRIPTOR_H_
+#define CLIENT_LINUX_HANDLER_MINIDUMP_DESCRIPTOR_H_
+
+#include <assert.h>
+#include <string>
+
+#include "common/using_std_string.h"
+
+// The MinidumpDescriptor describes how to access a minidump: it can contain
+// either a file descriptor or a path.
+// Note that when using files, it is created with the path to a directory.
+// The actual path where the minidump is generated is created by this class.
+namespace google_breakpad {
+
+class MinidumpDescriptor {
+ public:
+  MinidumpDescriptor() : fd_(-1) {}
+
+  explicit MinidumpDescriptor(const string& directory)
+      : fd_(-1),
+        directory_(directory),
+        c_path_(NULL) {
+    assert(!directory.empty());
+  }
+
+  explicit MinidumpDescriptor(int fd) : fd_(fd), c_path_(NULL) {
+    assert(fd != -1);
+  }
+
+  explicit MinidumpDescriptor(const MinidumpDescriptor& descriptor);
+  MinidumpDescriptor& operator=(const MinidumpDescriptor& descriptor);
+
+  bool IsFD() const { return fd_ != -1; }
+
+  int fd() const { return fd_; }
+
+  string directory() const { return directory_; }
+
+  const char* path() const { return c_path_; }
+
+  // Updates the path so it is unique.
+  // Should be called from a normal context: this methods uses the heap.
+  void UpdatePath();
+
+ private:
+  // The file descriptor where the minidump is generated.
+  int fd_;
+
+  // The directory where the minidump should be generated.
+  string directory_;
+  // The full path to the generated minidump.
+  string path_;
+  // The C string of |path_|. Precomputed so it can be access from a compromised
+  // context.
+  const char* c_path_;
+};
+
+}  // namespace google_breakpad
+
+#endif  // CLIENT_LINUX_HANDLER_MINIDUMP_DESCRIPTOR_H_

toolkit/crashreporter/google-breakpad/src/client/linux/log/log.cc

@@ -0,0 +1,48 @@
+// Copyright (c) 2012 Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#include "client/linux/log/log.h"
+
+#if defined(__ANDROID__)
+#include <android/log.h>
+#else
+#include "third_party/lss/linux_syscall_support.h"
+#endif
+
+namespace logger {
+
+int write(const char* buf, size_t nbytes) {
+#if defined(__ANDROID__)
+  return __android_log_write(ANDROID_LOG_WARN, "google-breakpad", buf);
+#else
+  return sys_write(2, buf, nbytes);
+#endif
+}
+
+}  // namespace logger

toolkit/crashreporter/google-breakpad/src/client/linux/log/log.h

@@ -1,4 +1,4 @@
-// Copyright (c) 2008, Google Inc.
+// Copyright (c) 2012, Google Inc.
 // All rights reserved.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -27,11 +27,15 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-// precompile.cpp : source file that includes just the standard includes
-// CrashGenerationApp.pch will be the pre-compiled header
-// precompile.obj will contain the pre-compiled type information
+#ifndef CLIENT_LINUX_LOG_LOG_H_
+#define CLIENT_LINUX_LOG_LOG_H_
 
-#include "precompile.h"
+#include <stddef.h>
 
-// Reference any additional headers you need in PRECOMPILE.H
-// and not in this file.
+namespace logger {
+
+int write(const char* buf, size_t nbytes);
+
+}  // namespace logger
+
+#endif  // CLIENT_LINUX_LOG_LOG_H_

toolkit/crashreporter/google-breakpad/src/client/linux/minidump_writer/Makefile.in

@@ -13,14 +13,21 @@ MODULE		= writer
 LIBRARY_NAME	= minidump_writer_s
 XPI_NAME 	= crashreporter
 
-LOCAL_INCLUDES 	= -I$(srcdir)/../../..
+LOCAL_INCLUDES = \
+  -I$(topsrcdir)/toolkit/crashreporter/google-breakpad/src \
+  $(NULL)
 
 CPPSRCS	= \
   linux_dumper.cc \
+  linux_ptrace_dumper.cc \
   minidump_writer.cc \
   $(NULL)
 
 # need static lib
 FORCE_STATIC_LIB = 1
 
+ifeq ($(OS_TARGET),Android)
+LOCAL_INCLUDES += -I$(topsrcdir)/toolkit/crashreporter/google-breakpad/src/common/android/include/
+endif
+
 include $(topsrcdir)/config/rules.mk

toolkit/crashreporter/google-breakpad/src/client/linux/minidump_writer/directory_reader.h

@@ -37,7 +37,8 @@
 #include <errno.h>
 #include <string.h>
 
-#include "common/linux/linux_syscall_support.h"
+#include "common/linux/linux_libc_support.h"
+#include "third_party/lss/linux_syscall_support.h"
 
 namespace google_breakpad {
 
@@ -90,7 +91,7 @@ class DirectoryReader {
       reinterpret_cast<kernel_dirent*>(buf_);
 
     buf_used_ -= dent->d_reclen;
-    memmove(buf_, buf_ + dent->d_reclen, buf_used_);
+    my_memmove(buf_, buf_ + dent->d_reclen, buf_used_);
   }
 
  private:

toolkit/crashreporter/google-breakpad/src/client/linux/minidump_writer/directory_reader_unittest.cc

@@ -35,6 +35,7 @@
 #include <sys/types.h>
 
 #include "client/linux/minidump_writer/directory_reader.h"
+#include "common/using_std_string.h"
 #include "breakpad_googletest_includes.h"
 
 using namespace google_breakpad;
@@ -44,7 +45,7 @@ typedef testing::Test DirectoryReaderTest;
 }
 
 TEST(DirectoryReaderTest, CompareResults) {
-  std::set<std::string> dent_set;
+  std::set<string> dent_set;
 
   DIR *const dir = opendir("/proc/self");
   ASSERT_TRUE(dir != NULL);

toolkit/crashreporter/google-breakpad/src/client/linux/minidump_writer/line_reader.h

@@ -34,7 +34,8 @@
 #include <assert.h>
 #include <string.h>
 
-#include "common/linux/linux_syscall_support.h"
+#include "common/linux/linux_libc_support.h"
+#include "third_party/lss/linux_syscall_support.h"
 
 namespace google_breakpad {
 
@@ -114,7 +115,7 @@ class LineReader {
 
     assert(buf_used_ >= len + 1);
     buf_used_ -= len + 1;
-    memmove(buf_, buf_ + len + 1, buf_used_);
+    my_memmove(buf_, buf_ + len + 1, buf_used_);
   }
 
  private:

toolkit/crashreporter/google-breakpad/src/client/linux/minidump_writer/line_reader_unittest.cc

@@ -33,11 +33,18 @@
 
 #include "client/linux/minidump_writer/line_reader.h"
 #include "breakpad_googletest_includes.h"
+#include "common/linux/eintr_wrapper.h"
 
 using namespace google_breakpad;
 
+#if !defined(__ANDROID__)
+#define TEMPDIR "/tmp"
+#else
+#define TEMPDIR "/data/local/tmp"
+#endif
+
 static int TemporaryFile() {
-  static const char templ[] = "/tmp/line-reader-unittest-XXXXXX";
+  static const char templ[] = TEMPDIR "/line-reader-unittest-XXXXXX";
   char templ_copy[sizeof(templ)];
   memcpy(templ_copy, templ, sizeof(templ));
   const int fd = mkstemp(templ_copy);
@@ -64,16 +71,17 @@ TEST(LineReaderTest, EmptyFile) {
 
 TEST(LineReaderTest, OneLineTerminated) {
   const int fd = TemporaryFile();
-  write(fd, "a\n", 2);
+  const int r = HANDLE_EINTR(write(fd, "a\n", 2));
+  ASSERT_EQ(2, r);
   lseek(fd, 0, SEEK_SET);
   LineReader reader(fd);
 
   const char *line;
   unsigned int len;
   ASSERT_TRUE(reader.GetNextLine(&line, &len));
-  ASSERT_EQ(len, (unsigned int)1);
-  ASSERT_EQ(line[0], 'a');
-  ASSERT_EQ(line[1], 0);
+  ASSERT_EQ((unsigned int)1, len);
+  ASSERT_EQ('a', line[0]);
+  ASSERT_EQ('\0', line[1]);
   reader.PopLine(len);
 
   ASSERT_FALSE(reader.GetNextLine(&line, &len));
@@ -83,16 +91,17 @@ TEST(LineReaderTest, OneLineTerminated) {
 
 TEST(LineReaderTest, OneLine) {
   const int fd = TemporaryFile();
-  write(fd, "a", 1);
+  const int r = HANDLE_EINTR(write(fd, "a", 1));
+  ASSERT_EQ(1, r);
   lseek(fd, 0, SEEK_SET);
   LineReader reader(fd);
 
   const char *line;
   unsigned len;
   ASSERT_TRUE(reader.GetNextLine(&line, &len));
-  ASSERT_EQ(len, (unsigned)1);
-  ASSERT_EQ(line[0], 'a');
-  ASSERT_EQ(line[1], 0);
+  ASSERT_EQ((unsigned)1, len);
+  ASSERT_EQ('a', line[0]);
+  ASSERT_EQ('\0', line[1]);
   reader.PopLine(len);
 
   ASSERT_FALSE(reader.GetNextLine(&line, &len));
@@ -102,22 +111,23 @@ TEST(LineReaderTest, OneLine) {
 
 TEST(LineReaderTest, TwoLinesTerminated) {
   const int fd = TemporaryFile();
-  write(fd, "a\nb\n", 4);
+  const int r = HANDLE_EINTR(write(fd, "a\nb\n", 4));
+  ASSERT_EQ(4, r);
   lseek(fd, 0, SEEK_SET);
   LineReader reader(fd);
 
   const char *line;
   unsigned len;
   ASSERT_TRUE(reader.GetNextLine(&line, &len));
-  ASSERT_EQ(len, (unsigned)1);
-  ASSERT_EQ(line[0], 'a');
-  ASSERT_EQ(line[1], 0);
+  ASSERT_EQ((unsigned)1, len);
+  ASSERT_EQ('a', line[0]);
+  ASSERT_EQ('\0', line[1]);
   reader.PopLine(len);
 
   ASSERT_TRUE(reader.GetNextLine(&line, &len));
-  ASSERT_EQ(len, (unsigned)1);
-  ASSERT_EQ(line[0], 'b');
-  ASSERT_EQ(line[1], 0);
+  ASSERT_EQ((unsigned)1, len);
+  ASSERT_EQ('b', line[0]);
+  ASSERT_EQ('\0', line[1]);
   reader.PopLine(len);
 
   ASSERT_FALSE(reader.GetNextLine(&line, &len));
@@ -127,22 +137,23 @@ TEST(LineReaderTest, TwoLinesTerminated) {
 
 TEST(LineReaderTest, TwoLines) {
   const int fd = TemporaryFile();
-  write(fd, "a\nb", 3);
+  const int r = HANDLE_EINTR(write(fd, "a\nb", 3));
+  ASSERT_EQ(3, r);
   lseek(fd, 0, SEEK_SET);
   LineReader reader(fd);
 
   const char *line;
   unsigned len;
   ASSERT_TRUE(reader.GetNextLine(&line, &len));
-  ASSERT_EQ(len, (unsigned)1);
-  ASSERT_EQ(line[0], 'a');
-  ASSERT_EQ(line[1], 0);
+  ASSERT_EQ((unsigned)1, len);
+  ASSERT_EQ('a', line[0]);
+  ASSERT_EQ('\0', line[1]);
   reader.PopLine(len);
 
   ASSERT_TRUE(reader.GetNextLine(&line, &len));
-  ASSERT_EQ(len, (unsigned)1);
-  ASSERT_EQ(line[0], 'b');
-  ASSERT_EQ(line[1], 0);
+  ASSERT_EQ((unsigned)1, len);
+  ASSERT_EQ('b', line[0]);
+  ASSERT_EQ('\0', line[1]);
   reader.PopLine(len);
 
   ASSERT_FALSE(reader.GetNextLine(&line, &len));
@@ -154,16 +165,17 @@ TEST(LineReaderTest, MaxLength) {
   const int fd = TemporaryFile();
   char l[LineReader::kMaxLineLen - 1];
   memset(l, 'a', sizeof(l));
-  write(fd, l, sizeof(l));
+  const int r = HANDLE_EINTR(write(fd, l, sizeof(l)));
+  ASSERT_EQ(sizeof(l), r);
   lseek(fd, 0, SEEK_SET);
   LineReader reader(fd);
 
   const char *line;
   unsigned len;
   ASSERT_TRUE(reader.GetNextLine(&line, &len));
-  ASSERT_EQ(len, sizeof(l));
+  ASSERT_EQ(sizeof(l), len);
   ASSERT_TRUE(memcmp(l, line, sizeof(l)) == 0);
-  ASSERT_EQ(line[len], 0);
+  ASSERT_EQ('\0', line[len]);
 
   close(fd);
 }
@@ -172,7 +184,8 @@ TEST(LineReaderTest, TooLong) {
   const int fd = TemporaryFile();
   char l[LineReader::kMaxLineLen];
   memset(l, 'a', sizeof(l));
-  write(fd, l, sizeof(l));
+  const int r = HANDLE_EINTR(write(fd, l, sizeof(l)));
+  ASSERT_EQ(sizeof(l), r);
   lseek(fd, 0, SEEK_SET);
   LineReader reader(fd);
 

toolkit/crashreporter/google-breakpad/src/client/linux/minidump_writer/linux_core_dumper.cc

@@ -0,0 +1,234 @@
+// Copyright (c) 2012, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// linux_core_dumper.cc: Implement google_breakpad::LinuxCoreDumper.
+// See linux_core_dumper.h for details.
+
+#include "client/linux/minidump_writer/linux_core_dumper.h"
+
+#include <asm/ptrace.h>
+#include <assert.h>
+#include <elf.h>
+#include <stdio.h>
+#include <string.h>
+#include <sys/procfs.h>
+
+#include "common/linux/linux_libc_support.h"
+
+namespace google_breakpad {
+
+LinuxCoreDumper::LinuxCoreDumper(pid_t pid,
+                                 const char* core_path,
+                                 const char* procfs_path)
+    : LinuxDumper(pid),
+      core_path_(core_path),
+      procfs_path_(procfs_path),
+      thread_infos_(&allocator_, 8) {
+  assert(core_path_);
+}
+
+bool LinuxCoreDumper::BuildProcPath(char* path, pid_t pid,
+                                    const char* node) const {
+  if (!path || !node)
+    return false;
+
+  size_t node_len = my_strlen(node);
+  if (node_len == 0)
+    return false;
+
+  size_t procfs_path_len = my_strlen(procfs_path_);
+  size_t total_length = procfs_path_len + 1 + node_len;
+  if (total_length >= NAME_MAX)
+    return false;
+
+  memcpy(path, procfs_path_, procfs_path_len);
+  path[procfs_path_len] = '/';
+  memcpy(path + procfs_path_len + 1, node, node_len);
+  path[total_length] = '\0';
+  return true;
+}
+
+void LinuxCoreDumper::CopyFromProcess(void* dest, pid_t child,
+                                      const void* src, size_t length) {
+  ElfCoreDump::Addr virtual_address = reinterpret_cast<ElfCoreDump::Addr>(src);
+  // TODO(benchan): Investigate whether the data to be copied could span
+  // across multiple segments in the core dump file. ElfCoreDump::CopyData
+  // and this method do not handle that case yet.
+  if (!core_.CopyData(dest, virtual_address, length)) {
+    // If the data segment is not found in the core dump, fill the result
+    // with marker characters.
+    memset(dest, 0xab, length);
+  }
+}
+
+bool LinuxCoreDumper::GetThreadInfoByIndex(size_t index, ThreadInfo* info) {
+  if (index >= thread_infos_.size())
+    return false;
+
+  *info = thread_infos_[index];
+  const uint8_t* stack_pointer;
+#if defined(__i386)
+  memcpy(&stack_pointer, &info->regs.esp, sizeof(info->regs.esp));
+#elif defined(__x86_64)
+  memcpy(&stack_pointer, &info->regs.rsp, sizeof(info->regs.rsp));
+#elif defined(__ARM_EABI__)
+  memcpy(&stack_pointer, &info->regs.ARM_sp, sizeof(info->regs.ARM_sp));
+#else
+#error "This code hasn't been ported to your platform yet."
+#endif
+
+  return GetStackInfo(&info->stack, &info->stack_len,
+                      reinterpret_cast<uintptr_t>(stack_pointer));
+}
+
+bool LinuxCoreDumper::IsPostMortem() const {
+  return true;
+}
+
+bool LinuxCoreDumper::ThreadsSuspend() {
+  return true;
+}
+
+bool LinuxCoreDumper::ThreadsResume() {
+  return true;
+}
+
+bool LinuxCoreDumper::EnumerateThreads() {
+  if (!mapped_core_file_.Map(core_path_)) {
+    fprintf(stderr, "Could not map core dump file into memory\n");
+    return false;
+  }
+
+  core_.SetContent(mapped_core_file_.content());
+  if (!core_.IsValid()) {
+    fprintf(stderr, "Invalid core dump file\n");
+    return false;
+  }
+
+  ElfCoreDump::Note note = core_.GetFirstNote();
+  if (!note.IsValid()) {
+    fprintf(stderr, "PT_NOTE section not found\n");
+    return false;
+  }
+
+  bool first_thread = true;
+  do {
+    ElfCoreDump::Word type = note.GetType();
+    MemoryRange name = note.GetName();
+    MemoryRange description = note.GetDescription();
+
+    if (type == 0 || name.IsEmpty() || description.IsEmpty()) {
+      fprintf(stderr, "Could not found a valid PT_NOTE.\n");
+      return false;
+    }
+
+    // Based on write_note_info() in linux/kernel/fs/binfmt_elf.c, notes are
+    // ordered as follows (NT_PRXFPREG and NT_386_TLS are i386 specific):
+    //   Thread           Name          Type
+    //   -------------------------------------------------------------------
+    //   1st thread       CORE          NT_PRSTATUS
+    //   process-wide     CORE          NT_PRPSINFO
+    //   process-wide     CORE          NT_AUXV
+    //   1st thread       CORE          NT_FPREGSET
+    //   1st thread       LINUX         NT_PRXFPREG
+    //   1st thread       LINUX         NT_386_TLS
+    //
+    //   2nd thread       CORE          NT_PRSTATUS
+    //   2nd thread       CORE          NT_FPREGSET
+    //   2nd thread       LINUX         NT_PRXFPREG
+    //   2nd thread       LINUX         NT_386_TLS
+    //
+    //   3rd thread       CORE          NT_PRSTATUS
+    //   3rd thread       CORE          NT_FPREGSET
+    //   3rd thread       LINUX         NT_PRXFPREG
+    //   3rd thread       LINUX         NT_386_TLS
+    //
+    // The following code only works if notes are ordered as expected.
+    switch (type) {
+      case NT_PRSTATUS: {
+        if (description.length() != sizeof(elf_prstatus)) {
+          fprintf(stderr, "Found NT_PRSTATUS descriptor of unexpected size\n");
+          return false;
+        }
+
+        const elf_prstatus* status =
+            reinterpret_cast<const elf_prstatus*>(description.data());
+        pid_t pid = status->pr_pid;
+        ThreadInfo info;
+        memset(&info, 0, sizeof(ThreadInfo));
+        info.tgid = status->pr_pgrp;
+        info.ppid = status->pr_ppid;
+        memcpy(&info.regs, status->pr_reg, sizeof(info.regs));
+        if (first_thread) {
+          crash_thread_ = pid;
+          crash_signal_ = status->pr_info.si_signo;
+        }
+        first_thread = false;
+        threads_.push_back(pid);
+        thread_infos_.push_back(info);
+        break;
+      }
+#if defined(__i386) || defined(__x86_64)
+      case NT_FPREGSET: {
+        if (thread_infos_.empty())
+          return false;
+
+        ThreadInfo* info = &thread_infos_.back();
+        if (description.length() != sizeof(info->fpregs)) {
+          fprintf(stderr, "Found NT_FPREGSET descriptor of unexpected size\n");
+          return false;
+        }
+
+        memcpy(&info->fpregs, description.data(), sizeof(info->fpregs));
+        break;
+      }
+#endif
+#if defined(__i386)
+      case NT_PRXFPREG: {
+        if (thread_infos_.empty())
+          return false;
+
+        ThreadInfo* info = &thread_infos_.back();
+        if (description.length() != sizeof(info->fpxregs)) {
+          fprintf(stderr, "Found NT_PRXFPREG descriptor of unexpected size\n");
+          return false;
+        }
+
+        memcpy(&info->fpxregs, description.data(), sizeof(info->fpxregs));
+        break;
+      }
+#endif
+    }
+    note = note.GetNextNote();
+  } while (note.IsValid());
+
+  return true;
+}
+
+}  // namespace google_breakpad

toolkit/crashreporter/google-breakpad/src/client/linux/minidump_writer/linux_core_dumper.h

@@ -0,0 +1,122 @@
+// Copyright (c) 2012, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// linux_core_dumper.h: Define the google_breakpad::LinuxCoreDumper
+// class, which is derived from google_breakpad::LinuxDumper to extract
+// information from a crashed process via its core dump and proc files.
+
+#ifndef CLIENT_LINUX_MINIDUMP_WRITER_LINUX_CORE_DUMPER_H_
+#define CLIENT_LINUX_MINIDUMP_WRITER_LINUX_CORE_DUMPER_H_
+
+#include "client/linux/minidump_writer/linux_dumper.h"
+#include "common/linux/elf_core_dump.h"
+#include "common/linux/memory_mapped_file.h"
+
+namespace google_breakpad {
+
+class LinuxCoreDumper : public LinuxDumper {
+ public:
+  // Constructs a dumper for extracting information of a given process
+  // with a process ID of |pid| via its core dump file at |core_path| and
+  // its proc files at |procfs_path|. If |procfs_path| is a copy of
+  // /proc/<pid>, it should contain the following files:
+  //     auxv, cmdline, environ, exe, maps, status
+  LinuxCoreDumper(pid_t pid, const char* core_path, const char* procfs_path);
+
+  // Implements LinuxDumper::BuildProcPath().
+  // Builds a proc path for a certain pid for a node (/proc/<pid>/<node>).
+  // |path| is a character array of at least NAME_MAX bytes to return the
+  // result.|node| is the final node without any slashes. Return true on
+  // success.
+  //
+  // As this dumper performs a post-mortem dump and makes use of a copy
+  // of the proc files of the crashed process, this derived method does
+  // not actually make use of |pid| and always returns a subpath of
+  // |procfs_path_| regardless of whether |pid| corresponds to the main
+  // process or a thread of the process, i.e. assuming both the main process
+  // and its threads have the following proc files with the same content:
+  //     auxv, cmdline, environ, exe, maps, status
+  virtual bool BuildProcPath(char* path, pid_t pid, const char* node) const;
+
+  // Implements LinuxDumper::CopyFromProcess().
+  // Copies content of |length| bytes from a given process |child|,
+  // starting from |src|, into |dest|. This method extracts the content
+  // the core dump and fills |dest| with a sequence of marker bytes
+  // if the expected data is not found in the core dump.
+  virtual void CopyFromProcess(void* dest, pid_t child, const void* src,
+                               size_t length);
+
+  // Implements LinuxDumper::GetThreadInfoByIndex().
+  // Reads information about the |index|-th thread of |threads_|.
+  // Returns true on success. One must have called |ThreadsSuspend| first.
+  virtual bool GetThreadInfoByIndex(size_t index, ThreadInfo* info);
+
+  // Implements LinuxDumper::IsPostMortem().
+  // Always returns true to indicate that this dumper performs a
+  // post-mortem dump of a crashed process via a core dump file.
+  virtual bool IsPostMortem() const;
+
+  // Implements LinuxDumper::ThreadsSuspend().
+  // As the dumper performs a post-mortem dump via a core dump file,
+  // there is no threads to suspend. This method does nothing and
+  // always returns true.
+  virtual bool ThreadsSuspend();
+
+  // Implements LinuxDumper::ThreadsResume().
+  // As the dumper performs a post-mortem dump via a core dump file,
+  // there is no threads to resume. This method does nothing and
+  // always returns true.
+  virtual bool ThreadsResume();
+
+ protected:
+  // Implements LinuxDumper::EnumerateThreads().
+  // Enumerates all threads of the given process into |threads_|.
+  virtual bool EnumerateThreads();
+
+ private:
+  // Path of the core dump file.
+  const char* core_path_;
+
+  // Path of the directory containing the proc files of the given process,
+  // which is usually a copy of /proc/<pid>.
+  const char* procfs_path_;
+
+  // Memory-mapped core dump file at |core_path_|.
+  MemoryMappedFile mapped_core_file_;
+
+  // Content of the core dump file.
+  ElfCoreDump core_;
+
+  // Thread info found in the core dump file.
+  wasteful_vector<ThreadInfo> thread_infos_;
+};
+
+}  // namespace google_breakpad
+
+#endif  // CLIENT_LINUX_HANDLER_LINUX_CORE_DUMPER_H_

toolkit/crashreporter/google-breakpad/src/client/linux/minidump_writer/linux_core_dumper_unittest.cc

@@ -0,0 +1,110 @@
+// Copyright (c) 2012, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// linux_core_dumper_unittest.cc:
+// Unit tests for google_breakpad::LinuxCoreDumoer.
+
+#include <string>
+
+#include "breakpad_googletest_includes.h"
+#include "client/linux/minidump_writer/linux_core_dumper.h"
+#include "common/linux/tests/crash_generator.h"
+#include "common/using_std_string.h"
+
+using namespace google_breakpad;
+
+TEST(LinuxCoreDumperTest, BuildProcPath) {
+  const pid_t pid = getpid();
+  const char procfs_path[] = "/procfs_copy";
+  LinuxCoreDumper dumper(getpid(), "core_file", procfs_path);
+
+  char maps_path[NAME_MAX] = "";
+  char maps_path_expected[NAME_MAX];
+  snprintf(maps_path_expected, sizeof(maps_path_expected),
+           "%s/maps", procfs_path);
+  EXPECT_TRUE(dumper.BuildProcPath(maps_path, pid, "maps"));
+  EXPECT_STREQ(maps_path_expected, maps_path);
+
+  EXPECT_FALSE(dumper.BuildProcPath(NULL, pid, "maps"));
+  EXPECT_FALSE(dumper.BuildProcPath(maps_path, pid, ""));
+  EXPECT_FALSE(dumper.BuildProcPath(maps_path, pid, NULL));
+
+  char long_node[NAME_MAX];
+  size_t long_node_len = NAME_MAX - strlen(procfs_path) - 1;
+  memset(long_node, 'a', long_node_len);
+  long_node[long_node_len] = '\0';
+  EXPECT_FALSE(dumper.BuildProcPath(maps_path, pid, long_node));
+}
+
+TEST(LinuxCoreDumperTest, VerifyDumpWithMultipleThreads) {
+  CrashGenerator crash_generator;
+  if (!crash_generator.HasDefaultCorePattern()) {
+    fprintf(stderr, "LinuxCoreDumperTest.VerifyDumpWithMultipleThreads test "
+            "is skipped due to non-default core pattern\n");
+    return;
+  }
+
+  const unsigned kNumOfThreads = 3;
+  const unsigned kCrashThread = 1;
+  const int kCrashSignal = SIGABRT;
+  pid_t child_pid;
+  // TODO(benchan): Revert to use ASSERT_TRUE once the flakiness in
+  // CrashGenerator is identified and fixed.
+  if (!crash_generator.CreateChildCrash(kNumOfThreads, kCrashThread,
+                                        kCrashSignal, &child_pid)) {
+    fprintf(stderr, "LinuxCoreDumperTest.VerifyDumpWithMultipleThreads test "
+            "is skipped due to no core dump generated\n");
+    return;
+  }
+
+  const string core_file = crash_generator.GetCoreFilePath();
+  const string procfs_path = crash_generator.GetDirectoryOfProcFilesCopy();
+  LinuxCoreDumper dumper(child_pid, core_file.c_str(), procfs_path.c_str());
+  EXPECT_TRUE(dumper.Init());
+
+  EXPECT_TRUE(dumper.IsPostMortem());
+
+  // These are no-ops and should always return true.
+  EXPECT_TRUE(dumper.ThreadsSuspend());
+  EXPECT_TRUE(dumper.ThreadsResume());
+
+  // LinuxCoreDumper cannot determine the crash address and thus it always
+  // sets the crash address to 0.
+  EXPECT_EQ(0, dumper.crash_address());
+  EXPECT_EQ(kCrashSignal, dumper.crash_signal());
+  EXPECT_EQ(crash_generator.GetThreadId(kCrashThread),
+            dumper.crash_thread());
+
+  EXPECT_EQ(kNumOfThreads, dumper.threads().size());
+  for (unsigned i = 0; i < kNumOfThreads; ++i) {
+    ThreadInfo info;
+    EXPECT_TRUE(dumper.GetThreadInfoByIndex(i, &info));
+    EXPECT_EQ(getpid(), info.ppid);
+  }
+}

toolkit/crashreporter/google-breakpad/src/client/linux/minidump_writer/linux_dumper.cc

@@ -1,4 +1,4 @@
-// Copyright (c) 2009, Google Inc.
+// Copyright (c) 2010, Google Inc.
 // All rights reserved.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -27,6 +27,9 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
+// linux_dumper.cc: Implement google_breakpad::LinuxDumper.
+// See linux_dumper.h for details.
+
 // This code deals with the mechanics of getting information about a crashed
 // process. Since this code may run in a compromised address space, the same
 // rules apply as detailed at the top of minidump_writer.h: no libc calls and
@@ -35,77 +38,22 @@
 #include "client/linux/minidump_writer/linux_dumper.h"
 
 #include <assert.h>
+#include <fcntl.h>
 #include <limits.h>
 #include <stddef.h>
-#include <stdlib.h>
-#include <stdio.h>
 #include <string.h>
 
-#include <unistd.h>
-#include <elf.h>
-#include <errno.h>
-#include <fcntl.h>
-#if !defined(__ANDROID__)
-#include <link.h>
-#endif
-
-#include <sys/types.h>
-#include <sys/ptrace.h>
-#include <sys/wait.h>
-
-#include <algorithm>
-
-#include "client/linux/minidump_writer/directory_reader.h"
 #include "client/linux/minidump_writer/line_reader.h"
 #include "common/linux/file_id.h"
 #include "common/linux/linux_libc_support.h"
-#include "common/linux/linux_syscall_support.h"
+#include "common/linux/memory_mapped_file.h"
+#include "common/linux/safe_readlink.h"
+#include "third_party/lss/linux_syscall_support.h"
 
 static const char kMappedFileUnsafePrefix[] = "/dev/";
+static const char kDeletedSuffix[] = " (deleted)";
 
-namespace google_breakpad {
-
-bool AttachThread(pid_t pid) {
-  // This may fail if the thread has just died or debugged.
-  errno = 0;
-  if (sys_ptrace(PTRACE_ATTACH, pid, NULL, NULL) != 0 &&
-      errno != 0) {
-    return false;
-  }
-  while (sys_waitpid(pid, NULL, __WALL) < 0) {
-    if (errno != EINTR) {
-      sys_ptrace(PTRACE_DETACH, pid, NULL, NULL);
-      return false;
-    }
-  }
-#if defined(__i386) || defined(__x86_64)
-  // On x86, the stack pointer is NULL or -1, when executing trusted code in
-  // the seccomp sandbox. Not only does this cause difficulties down the line
-  // when trying to dump the thread's stack, it also results in the minidumps
-  // containing information about the trusted threads. This information is
-  // generally completely meaningless and just pollutes the minidumps.
-  // We thus test the stack pointer and exclude any threads that are part of
-  // the seccomp sandbox's trusted code.
-  user_regs_struct regs;
-  if (sys_ptrace(PTRACE_GETREGS, pid, NULL, &regs) == -1 ||
-#if defined(__i386)
-      !regs.esp
-#elif defined(__x86_64)
-      !regs.rsp
-#endif
-      ) {
-    sys_ptrace(PTRACE_DETACH, pid, NULL, NULL);
-    return false;
-  }
-#endif
-  return true;
-}
-
-bool DetachThread(pid_t pid) {
-  return sys_ptrace(PTRACE_DETACH, pid, NULL, NULL) >= 0;
-}
-
-inline bool IsMappedFileOpenUnsafe(
+inline static bool IsMappedFileOpenUnsafe(
     const google_breakpad::MappingInfo& mapping) {
   // It is unsafe to attempt to open a mapped file that lives under /dev,
   // because the semantics of the open may be driver-specific so we'd risk
@@ -116,173 +64,82 @@ inline bool IsMappedFileOpenUnsafe(
                     sizeof(kMappedFileUnsafePrefix) - 1) == 0;
 }
 
-bool GetThreadRegisters(ThreadInfo* info) {
-  pid_t tid = info->tid;
-
-  if (sys_ptrace(PTRACE_GETREGS, tid, NULL, &info->regs) == -1) {
-    return false;
-  }
-
-#if !defined(__ANDROID__)
-  if (sys_ptrace(PTRACE_GETFPREGS, tid, NULL, &info->fpregs) == -1) {
-    return false;
-  }
-#endif
-
-#if defined(__i386)
-  if (sys_ptrace(PTRACE_GETFPXREGS, tid, NULL, &info->fpxregs) == -1)
-    return false;
-#endif
-
-#if defined(__i386) || defined(__x86_64)
-  for (unsigned i = 0; i < ThreadInfo::kNumDebugRegisters; ++i) {
-    if (sys_ptrace(
-        PTRACE_PEEKUSER, tid,
-        reinterpret_cast<void*> (offsetof(struct user,
-                                          u_debugreg[0]) + i *
-                                 sizeof(debugreg_t)),
-        &info->dregs[i]) == -1) {
-      return false;
-    }
-  }
-#endif
-
-  return true;
-}
+namespace google_breakpad {
 
 // All interesting auvx entry types are below AT_SYSINFO_EHDR
 #define AT_MAX AT_SYSINFO_EHDR
 
-LinuxDumper::LinuxDumper(int pid)
+LinuxDumper::LinuxDumper(pid_t pid)
     : pid_(pid),
-      threads_suspended_(false),
+      crash_address_(0),
+      crash_signal_(0),
+      crash_thread_(0),
       threads_(&allocator_, 8),
       mappings_(&allocator_),
       auxv_(&allocator_, AT_MAX + 1) {
 }
 
+LinuxDumper::~LinuxDumper() {
+}
+
 bool LinuxDumper::Init() {
-  return ReadAuxv() &&
-         EnumerateThreads(&threads_) &&
-         EnumerateMappings(&mappings_);
-}
-
-bool LinuxDumper::ThreadsAttach() {
-  if (threads_suspended_)
-    return true;
-  for (size_t i = 0; i < threads_.size(); ++i) {
-    if (!AttachThread(threads_[i])) {
-      // If the thread either disappeared before we could attach to it, or if
-      // it was part of the seccomp sandbox's trusted code, it is OK to
-      // silently drop it from the minidump.
-      memmove(&threads_[i], &threads_[i+1],
-              (threads_.size() - i - 1) * sizeof(threads_[i]));
-      threads_.resize(threads_.size() - 1);
-      --i;
-    }
-  }
-  threads_suspended_ = true;
-  return threads_.size() > 0;
-}
-
-bool LinuxDumper::ThreadsDetach() {
-  if (!threads_suspended_)
-    return false;
-  bool good = true;
-  for (size_t i = 0; i < threads_.size(); ++i)
-    good &= DetachThread(threads_[i]);
-  threads_suspended_ = false;
-  return good;
-}
-
-void
-LinuxDumper::BuildProcPath(char* path, pid_t pid, const char* node) const {
-  assert(path);
-  if (!path) {
-    return;
-  }
-
-  path[0] = '\0';
-
-  const unsigned pid_len = my_int_len(pid);
-
-  assert(node);
-  if (!node) {
-    return;
-  }
-
-  size_t node_len = my_strlen(node);
-  assert(node_len < NAME_MAX);
-  if (node_len >= NAME_MAX) {
-    return;
-  }
-
-  assert(node_len > 0);
-  if (node_len == 0) {
-    return;
-  }
-
-  assert(pid > 0);
-  if (pid <= 0) {
-    return;
-  }
-
-  const size_t total_length = 6 + pid_len + 1 + node_len;
-
-  assert(total_length < NAME_MAX);
-  if (total_length >= NAME_MAX) {
-    return;
-  }
-
-  memcpy(path, "/proc/", 6);
-  my_itos(path + 6, pid, pid_len);
-  memcpy(path + 6 + pid_len, "/", 1);
-  memcpy(path + 6 + pid_len + 1, node, node_len);
-  memcpy(path + total_length, "\0", 1);
+  return ReadAuxv() && EnumerateThreads() && EnumerateMappings();
 }
 
 bool
 LinuxDumper::ElfFileIdentifierForMapping(const MappingInfo& mapping,
+                                         bool member,
+                                         unsigned int mapping_id,
                                          uint8_t identifier[sizeof(MDGUID)])
 {
+  assert(!member || mapping_id < mappings_.size());
   my_memset(identifier, 0, sizeof(MDGUID));
-  if (IsMappedFileOpenUnsafe(mapping)) {
-    return false;
-  }
-  int fd = sys_open(mapping.name, O_RDONLY, 0);
-  if (fd < 0)
+  if (IsMappedFileOpenUnsafe(mapping))
     return false;
 
-#if defined(__x86_64)
-#define sys_mmap2 sys_mmap
-  struct kernel_stat st;
-  if (sys_fstat(fd, &st) != 0) {
-#else
-  struct kernel_stat64 st;
-  if (sys_fstat64(fd, &st) != 0) {
-#endif
-    sys_close(fd);
-    return false;
+  // Special-case linux-gate because it's not a real file.
+  if (my_strcmp(mapping.name, kLinuxGateLibraryName) == 0) {
+    const uintptr_t kPageSize = getpagesize();
+    void* linux_gate = NULL;
+    if (pid_ == sys_getpid()) {
+      linux_gate = reinterpret_cast<void*>(mapping.start_addr);
+    } else {
+      linux_gate = allocator_.Alloc(kPageSize);
+      CopyFromProcess(linux_gate, pid_,
+                      reinterpret_cast<const void*>(mapping.start_addr),
+                      kPageSize);
+    }
+    return FileID::ElfFileIdentifierFromMappedFile(linux_gate, identifier);
   }
 
-  void* base = sys_mmap2(NULL, st.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
-  sys_close(fd);
-  if (base == MAP_FAILED) {
+  char filename[NAME_MAX];
+  size_t filename_len = my_strlen(mapping.name);
+  assert(filename_len < NAME_MAX);
+  if (filename_len >= NAME_MAX)
     return false;
+  my_memcpy(filename, mapping.name, filename_len);
+  filename[filename_len] = '\0';
+  bool filename_modified = HandleDeletedFileInMapping(filename);
+
+  MemoryMappedFile mapped_file(filename);
+  if (!mapped_file.data())  // Should probably check if size >= ElfW(Ehdr)?
+    return false;
+
+  bool success =
+      FileID::ElfFileIdentifierFromMappedFile(mapped_file.data(), identifier);
+  if (success && member && filename_modified) {
+    mappings_[mapping_id]->name[filename_len -
+                                sizeof(kDeletedSuffix) + 1] = '\0';
   }
 
-  bool success = FileID::ElfFileIdentifierFromMappedFile(base, identifier);
-  sys_munmap(base, st.st_size);
   return success;
 }
 
-bool
-LinuxDumper::ReadAuxv() {
-  char auxv_path[80];
-  BuildProcPath(auxv_path, pid_, "auxv");
-
-  // If BuildProcPath errors out due to invalid input, we'll handle it when
-  // we try to sys_open the file.
+bool LinuxDumper::ReadAuxv() {
+  char auxv_path[NAME_MAX];
+  if (!BuildProcPath(auxv_path, pid_, "auxv")) {
+    return false;
+  }
 
   int fd = sys_open(auxv_path, O_RDONLY, 0);
   if (fd < 0) {
@@ -300,14 +157,14 @@ LinuxDumper::ReadAuxv() {
       res = true;
     }
   }
-  close(fd);
+  sys_close(fd);
   return res;
 }
 
-bool
-LinuxDumper::EnumerateMappings(wasteful_vector<MappingInfo*>* result) const {
-  char maps_path[80];
-  BuildProcPath(maps_path, pid_, "maps");
+bool LinuxDumper::EnumerateMappings() {
+  char maps_path[NAME_MAX];
+  if (!BuildProcPath(maps_path, pid_, "maps"))
+    return false;
 
   // linux_gate_loc is the beginning of the kernel's mapping of
   // linux-gate.so in the process.  It doesn't actually show up in the
@@ -316,8 +173,12 @@ LinuxDumper::EnumerateMappings(wasteful_vector<MappingInfo*>* result) const {
   // case its entry when creating the list of mappings.
   // See http://www.trilithium.com/johan/2005/08/linux-gate/ for more
   // information.
-  const void* linux_gate_loc;
-  linux_gate_loc = reinterpret_cast<void *>(auxv_[AT_SYSINFO_EHDR]);
+  const void* linux_gate_loc =
+      reinterpret_cast<void *>(auxv_[AT_SYSINFO_EHDR]);
+  // Although the initial executable is usually the first mapping, it's not
+  // guaranteed (see http://crosbug.com/25355); therefore, try to use the
+  // actual entry point to find the mapping.
+  const void* entry_point_loc = reinterpret_cast<void *>(auxv_[AT_ENTRY]);
 
   const int fd = sys_open(maps_path, O_RDONLY, 0);
   if (fd < 0)
@@ -346,8 +207,8 @@ LinuxDumper::EnumerateMappings(wasteful_vector<MappingInfo*>* result) const {
           }
           // Merge adjacent mappings with the same name into one module,
           // assuming they're a single library mapped by the dynamic linker
-          if (name && result->size()) {
-            MappingInfo* module = (*result)[result->size() - 1];
+          if (name && !mappings_.empty()) {
+            MappingInfo* module = mappings_.back();
             if ((start_addr == module->start_addr + module->size) &&
                 (my_strlen(name) == my_strlen(module->name)) &&
                 (my_strncmp(name, module->name, my_strlen(name)) == 0)) {
@@ -357,16 +218,34 @@ LinuxDumper::EnumerateMappings(wasteful_vector<MappingInfo*>* result) const {
             }
           }
           MappingInfo* const module = new(allocator_) MappingInfo;
-          memset(module, 0, sizeof(MappingInfo));
+          my_memset(module, 0, sizeof(MappingInfo));
           module->start_addr = start_addr;
           module->size = end_addr - start_addr;
           module->offset = offset;
           if (name != NULL) {
             const unsigned l = my_strlen(name);
             if (l < sizeof(module->name))
-              memcpy(module->name, name, l);
+              my_memcpy(module->name, name, l);
+          }
+          // If this is the entry-point mapping, and it's not already the
+          // first one, then we need to make it be first.  This is because
+          // the minidump format assumes the first module is the one that
+          // corresponds to the main executable (as codified in
+          // processor/minidump.cc:MinidumpModuleList::GetMainModule()).
+          if (entry_point_loc &&
+              (entry_point_loc >=
+                  reinterpret_cast<void*>(module->start_addr)) &&
+              (entry_point_loc <
+                  reinterpret_cast<void*>(module->start_addr+module->size)) &&
+              !mappings_.empty()) {
+            // push the module onto the front of the list.
+            mappings_.resize(mappings_.size() + 1);
+            for (size_t idx = mappings_.size() - 1; idx > 0; idx--)
+              mappings_[idx] = mappings_[idx - 1];
+            mappings_[0] = module;
+          } else {
+            mappings_.push_back(module);
           }
-          result->push_back(module);
         }
       }
     }
@@ -375,93 +254,7 @@ LinuxDumper::EnumerateMappings(wasteful_vector<MappingInfo*>* result) const {
 
   sys_close(fd);
 
-  return result->size() > 0;
-}
-
-// Parse /proc/$pid/task to list all the threads of the process identified by
-// pid.
-bool LinuxDumper::EnumerateThreads(wasteful_vector<pid_t>* result) const {
-  char task_path[80];
-  BuildProcPath(task_path, pid_, "task");
-
-  const int fd = sys_open(task_path, O_RDONLY | O_DIRECTORY, 0);
-  if (fd < 0)
-    return false;
-  DirectoryReader* dir_reader = new(allocator_) DirectoryReader(fd);
-
-  // The directory may contain duplicate entries which we filter by assuming
-  // that they are consecutive.
-  int last_tid = -1;
-  const char* dent_name;
-  while (dir_reader->GetNextEntry(&dent_name)) {
-    if (my_strcmp(dent_name, ".") &&
-        my_strcmp(dent_name, "..")) {
-      int tid = 0;
-      if (my_strtoui(&tid, dent_name) &&
-          last_tid != tid) {
-        last_tid = tid;
-        result->push_back(tid);
-      }
-    }
-    dir_reader->PopEntry();
-  }
-
-  sys_close(fd);
-  return true;
-}
-
-// Read thread info from /proc/$pid/status.
-// Fill out the |tgid|, |ppid| and |pid| members of |info|. If unavailable,
-// these members are set to -1. Returns true iff all three members are
-// available.
-bool LinuxDumper::ThreadInfoGet(ThreadInfo* info) {
-  assert(info != NULL);
-  pid_t tid = info->tid;
-  char status_path[80];
-  BuildProcPath(status_path, tid, "status");
-
-  const int fd = open(status_path, O_RDONLY);
-  if (fd < 0)
-    return false;
-
-  LineReader* const line_reader = new(allocator_) LineReader(fd);
-  const char* line;
-  unsigned line_len;
-
-  info->ppid = info->tgid = -1;
-
-  while (line_reader->GetNextLine(&line, &line_len)) {
-    if (my_strncmp("Tgid:\t", line, 6) == 0) {
-      my_strtoui(&info->tgid, line + 6);
-    } else if (my_strncmp("PPid:\t", line, 6) == 0) {
-      my_strtoui(&info->ppid, line + 6);
-    }
-
-    line_reader->PopLine(line_len);
-  }
-
-  if (info->ppid == -1 || info->tgid == -1)
-    return false;
-
-  if (!GetThreadRegisters(info))
-      return false;
-
-  const uint8_t* stack_pointer;
-#if defined(__i386)
-  memcpy(&stack_pointer, &info->regs.esp, sizeof(info->regs.esp));
-#elif defined(__x86_64)
-  memcpy(&stack_pointer, &info->regs.rsp, sizeof(info->regs.rsp));
-#elif defined(__ARM_EABI__)
-  memcpy(&stack_pointer, &info->regs.ARM_sp, sizeof(info->regs.ARM_sp));
-#else
-#error "This code hasn't been ported to your platform yet."
-#endif
-
-  if (!GetStackInfo(&info->stack, &info->stack_len,
-                    (uintptr_t) stack_pointer))
-    return false;
-
-  return true;
+  return !mappings_.empty();
 }
 
 // Get information about the stack, given the stack pointer. We don't try to
@@ -476,7 +269,7 @@ bool LinuxDumper::GetStackInfo(const void** stack, size_t* stack_len,
       reinterpret_cast<uint8_t*>(int_stack_pointer & ~(page_size - 1));
 
   // The number of bytes of stack which we try to capture.
-  static ptrdiff_t kStackToCapture = 32 * 1024;
+  static const ptrdiff_t kStackToCapture = 32 * 1024;
 
   const MappingInfo* mapping = FindMapping(stack_pointer);
   if (!mapping)
@@ -490,25 +283,6 @@ bool LinuxDumper::GetStackInfo(const void** stack, size_t* stack_len,
   return true;
 }
 
-// static
-void LinuxDumper::CopyFromProcess(void* dest, pid_t child, const void* src,
-                                  size_t length) {
-  unsigned long tmp = 55;
-  size_t done = 0;
-  static const size_t word_size = sizeof(tmp);
-  uint8_t* const local = (uint8_t*) dest;
-  uint8_t* const remote = (uint8_t*) src;
-
-  while (done < length) {
-    const size_t l = length - done > word_size ? word_size : length - done;
-    if (sys_ptrace(PTRACE_PEEKDATA, child, remote + done, &tmp) == -1) {
-      tmp = 0;
-    }
-    memcpy(local + done, &tmp, l);
-    done += l;
-  }
-}
-
 // Find the mapping which the given memory address falls in.
 const MappingInfo* LinuxDumper::FindMapping(const void* address) const {
   const uintptr_t addr = (uintptr_t) address;
@@ -522,4 +296,41 @@ const MappingInfo* LinuxDumper::FindMapping(const void* address) const {
   return NULL;
 }
 
+bool LinuxDumper::HandleDeletedFileInMapping(char* path) const {
+  static const size_t kDeletedSuffixLen = sizeof(kDeletedSuffix) - 1;
+
+  // Check for ' (deleted)' in |path|.
+  // |path| has to be at least as long as "/x (deleted)".
+  const size_t path_len = my_strlen(path);
+  if (path_len < kDeletedSuffixLen + 2)
+    return false;
+  if (my_strncmp(path + path_len - kDeletedSuffixLen, kDeletedSuffix,
+                 kDeletedSuffixLen) != 0) {
+    return false;
+  }
+
+  // Check |path| against the /proc/pid/exe 'symlink'.
+  char exe_link[NAME_MAX];
+  char new_path[NAME_MAX];
+  if (!BuildProcPath(exe_link, pid_, "exe"))
+    return false;
+  if (!SafeReadLink(exe_link, new_path))
+    return false;
+  if (my_strcmp(path, new_path) != 0)
+    return false;
+
+  // Check to see if someone actually named their executable 'foo (deleted)'.
+  struct kernel_stat exe_stat;
+  struct kernel_stat new_path_stat;
+  if (sys_stat(exe_link, &exe_stat) == 0 &&
+      sys_stat(new_path, &new_path_stat) == 0 &&
+      exe_stat.st_dev == new_path_stat.st_dev &&
+      exe_stat.st_ino == new_path_stat.st_ino) {
+    return false;
+  }
+
+  my_memcpy(path, exe_link, NAME_MAX);
+  return true;
+}
+
 }  // namespace google_breakpad

toolkit/crashreporter/google-breakpad/src/client/linux/minidump_writer/linux_dumper.h

@@ -1,4 +1,4 @@
-// Copyright (c) 2009, Google Inc.
+// Copyright (c) 2010, Google Inc.
 // All rights reserved.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -27,6 +27,14 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
+// linux_dumper.h: Define the google_breakpad::LinuxDumper class, which
+// is a base class for extracting information of a crashed process. It
+// was originally a complete implementation using the ptrace API, but
+// has been refactored to allow derived implementations supporting both
+// ptrace and core dump. A portion of the original implementation is now
+// in google_breakpad::LinuxPtraceDumper (see linux_ptrace_dumper.h for
+// details).
+
 #ifndef CLIENT_LINUX_MINIDUMP_WRITER_LINUX_DUMPER_H_
 #define CLIENT_LINUX_MINIDUMP_WRITER_LINUX_DUMPER_H_
 
@@ -34,13 +42,10 @@
 #include <linux/limits.h>
 #include <stdint.h>
 #include <sys/types.h>
-#if !defined(__ANDROID__)
 #include <sys/user.h>
-#endif
 
 #include "common/memory.h"
 #include "google_breakpad/common/minidump_format.h"
-#include <asm/ptrace.h>
 
 namespace google_breakpad {
 
@@ -50,24 +55,8 @@ typedef typeof(((struct user*) 0)->u_debugreg[0]) debugreg_t;
 
 // Typedef for our parsing of the auxv variables in /proc/pid/auxv.
 #if defined(__i386) || defined(__ARM_EABI__)
-#if !defined(__ANDROID__)
 typedef Elf32_auxv_t elf_aux_entry;
-#else
-// Android is missing this structure definition
-typedef struct
-{
-  uint32_t a_type;              /* Entry type */
-  union
-    {
-      uint32_t a_val;           /* Integer value */
-    } a_un;
-} elf_aux_entry;
-
-#if !defined(AT_SYSINFO_EHDR)
-#define AT_SYSINFO_EHDR 33
-#endif
-#endif  // __ANDROID__
-#elif defined(__x86_64__)
+#elif defined(__x86_64)
 typedef Elf64_auxv_t elf_aux_entry;
 #endif
 
@@ -80,7 +69,6 @@ const char kLinuxGateLibraryName[] = "linux-gate.so";
 
 // We produce one of these structures for each thread in the crashed process.
 struct ThreadInfo {
-  pid_t tid;    // thread id
   pid_t tgid;   // thread group id
   pid_t ppid;   // parent process
 
@@ -101,12 +89,8 @@ struct ThreadInfo {
 
 #elif defined(__ARM_EABI__)
   // Mimicking how strace does this(see syscall.c, search for GETREGS)
-#if defined(__ANDROID__)
-  struct pt_regs regs;
-#else
   struct user_regs regs;
   struct user_fpregs fpregs;
-#endif  // __ANDROID__
 #endif
 };
 
@@ -119,36 +103,31 @@ struct MappingInfo {
   char name[NAME_MAX];
 };
 
-// Suspend a thread by attaching to it.
-bool AttachThread(pid_t pid);
-
-// Resume a thread by detaching from it.
-bool DetachThread(pid_t pid);
-
-// Fill |info| with the register state of |info->tid|.  The thread
-// must be attached to the calling process.  Return true on success.
-bool GetThreadRegisters(ThreadInfo* info);
-
 class LinuxDumper {
  public:
   explicit LinuxDumper(pid_t pid);
 
+  virtual ~LinuxDumper();
+
   // Parse the data for |threads| and |mappings|.
-  bool Init();
+  virtual bool Init();
 
-  // Attach/detach all threads in the given process.
-  bool ThreadsAttach();
-  bool ThreadsDetach();
+  // Return true if the dumper performs a post-mortem dump.
+  virtual bool IsPostMortem() const = 0;
 
-  // Read information about the given thread. Returns true on success. One must
-  // have called |ThreadsAttach| first.
-  bool ThreadInfoGet(ThreadInfo* info);
+  // Suspend/resume all threads in the given process.
+  virtual bool ThreadsSuspend() = 0;
+  virtual bool ThreadsResume() = 0;
+
+  // Read information about the |index|-th thread of |threads_|.
+  // Returns true on success. One must have called |ThreadsSuspend| first.
+  virtual bool GetThreadInfoByIndex(size_t index, ThreadInfo* info) = 0;
 
   // These are only valid after a call to |Init|.
   const wasteful_vector<pid_t> &threads() { return threads_; }
   const wasteful_vector<MappingInfo*> &mappings() { return mappings_; }
   const MappingInfo* FindMapping(const void* address) const;
-  const wasteful_vector<elf_aux_val_t> &auxv() { return auxv_; }
+  const wasteful_vector<elf_aux_val_t>& auxv() { return auxv_; }
 
   // Find a block of memory to take as the stack given the top of stack pointer.
   //   stack: (output) the lowest address in the memory area
@@ -158,32 +137,75 @@ class LinuxDumper {
 
   PageAllocator* allocator() { return &allocator_; }
 
-  // memcpy from a remote process.
-  static void CopyFromProcess(void* dest, pid_t child, const void* src,
-                              size_t length);
+  // Copy content of |length| bytes from a given process |child|,
+  // starting from |src|, into |dest|.
+  virtual void CopyFromProcess(void* dest, pid_t child, const void* src,
+                               size_t length) = 0;
 
-  // Builds a proc path for a certain pid for a node.  path is a
-  // character array that is overwritten, and node is the final node
-  // without any slashes.
-  void BuildProcPath(char* path, pid_t pid, const char* node) const;
+  // Builds a proc path for a certain pid for a node (/proc/<pid>/<node>).
+  // |path| is a character array of at least NAME_MAX bytes to return the
+  // result.|node| is the final node without any slashes. Returns true on
+  // success.
+  virtual bool BuildProcPath(char* path, pid_t pid, const char* node) const = 0;
 
-  // Generate a File ID from the .text section of a mapped entry
+  // Generate a File ID from the .text section of a mapped entry.
+  // If not a member, mapping_id is ignored.
   bool ElfFileIdentifierForMapping(const MappingInfo& mapping,
+                                   bool member,
+                                   unsigned int mapping_id,
                                    uint8_t identifier[sizeof(MDGUID)]);
 
- private:
-  bool ReadAuxv();
-  bool EnumerateMappings(wasteful_vector<MappingInfo*>* result) const;
-  bool EnumerateThreads(wasteful_vector<pid_t>* result) const;
+  uintptr_t crash_address() const { return crash_address_; }
+  void set_crash_address(uintptr_t crash_address) {
+    crash_address_ = crash_address;
+  }
 
+  int crash_signal() const { return crash_signal_; }
+  void set_crash_signal(int crash_signal) { crash_signal_ = crash_signal; }
+
+  pid_t crash_thread() const { return crash_thread_; }
+  void set_crash_thread(pid_t crash_thread) { crash_thread_ = crash_thread; }
+
+ protected:
+  bool ReadAuxv();
+
+  virtual bool EnumerateMappings();
+
+  virtual bool EnumerateThreads() = 0;
+
+  // For the case where a running program has been deleted, it'll show up in
+  // /proc/pid/maps as "/path/to/program (deleted)". If this is the case, then
+  // see if '/path/to/program (deleted)' matches /proc/pid/exe and return
+  // /proc/pid/exe in |path| so ELF identifier generation works correctly. This
+  // also checks to see if '/path/to/program (deleted)' exists, so it does not
+  // get fooled by a poorly named binary.
+  // For programs that don't end with ' (deleted)', this is a no-op.
+  // This assumes |path| is a buffer with length NAME_MAX.
+  // Returns true if |path| is modified.
+  bool HandleDeletedFileInMapping(char* path) const;
+
+   // ID of the crashed process.
   const pid_t pid_;
 
+  // Virtual address at which the process crashed.
+  uintptr_t crash_address_;
+
+  // Signal that terminated the crashed process.
+  int crash_signal_;
+
+  // ID of the crashed thread.
+  pid_t crash_thread_;
+
   mutable PageAllocator allocator_;
 
-  bool threads_suspended_;
-  wasteful_vector<pid_t> threads_;  // the ids of all the threads
-  wasteful_vector<MappingInfo*> mappings_;  // info from /proc/<pid>/maps
-  wasteful_vector<elf_aux_val_t> auxv_;  // info from /proc/<pid>/auxv
+  // IDs of all the threads.
+  wasteful_vector<pid_t> threads_;
+
+  // Info from /proc/<pid>/maps.
+  wasteful_vector<MappingInfo*> mappings_;
+
+  // Info from /proc/<pid>/auxv
+  wasteful_vector<elf_aux_val_t> auxv_;
 };
 
 }  // namespace google_breakpad

toolkit/crashreporter/google-breakpad/src/client/linux/minidump_writer/linux_dumper_unittest.cc

@@ -1,236 +0,0 @@
-// Copyright (c) 2009, Google Inc.
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-#include <limits.h>
-#include <unistd.h>
-#include <signal.h>
-#include <sys/types.h>
-
-#include "breakpad_googletest_includes.h"
-#include "client/linux/minidump_writer/linux_dumper.h"
-#include "common/linux/file_id.h"
-#include "common/memory.h"
-
-using namespace google_breakpad;
-
-// This provides a wrapper around system calls which may be
-// interrupted by a signal and return EINTR. See man 7 signal.
-#define HANDLE_EINTR(x) ({ \
-  typeof(x) __eintr_result__; \
-  do { \
-    __eintr_result__ = x; \
-  } while (__eintr_result__ == -1 && errno == EINTR); \
-  __eintr_result__;\
-})
-
-namespace {
-typedef testing::Test LinuxDumperTest;
-}
-
-TEST(LinuxDumperTest, Setup) {
-  LinuxDumper dumper(getpid());
-}
-
-TEST(LinuxDumperTest, FindMappings) {
-  LinuxDumper dumper(getpid());
-  ASSERT_TRUE(dumper.Init());
-
-  ASSERT_TRUE(dumper.FindMapping(reinterpret_cast<void*>(getpid)));
-  ASSERT_TRUE(dumper.FindMapping(reinterpret_cast<void*>(printf)));
-  ASSERT_FALSE(dumper.FindMapping(NULL));
-}
-
-TEST(LinuxDumperTest, ThreadList) {
-  LinuxDumper dumper(getpid());
-  ASSERT_TRUE(dumper.Init());
-
-  ASSERT_GE(dumper.threads().size(), (size_t)1);
-  bool found = false;
-  for (size_t i = 0; i < dumper.threads().size(); ++i) {
-    if (dumper.threads()[i] == getpid()) {
-      found = true;
-      break;
-    }
-  }
-}
-
-TEST(LinuxDumperTest, VerifyStackReadWithMultipleThreads) {
-  static const int kNumberOfThreadsInHelperProgram = 5;
-  char kNumberOfThreadsArgument[2];
-  sprintf(kNumberOfThreadsArgument, "%d", kNumberOfThreadsInHelperProgram);
-
-  pid_t child_pid = fork();
-  if (child_pid == 0) {
-    // Set the number of threads
-    execl("src/client/linux/linux_dumper_unittest_helper",
-          "linux_dumper_unittest_helper",
-          kNumberOfThreadsArgument,
-          NULL);
-    // Kill if we get here.
-    printf("Errno from exec: %d", errno);
-    FAIL() << "Exec failed: " << strerror(errno);
-    exit(0);
-  }
-  // The sleep is flaky, but prevents us from reading
-  // the child process before all threads have been created.
-  sleep(1);
-  LinuxDumper dumper(child_pid);
-  EXPECT_TRUE(dumper.Init());
-  EXPECT_EQ((size_t)kNumberOfThreadsInHelperProgram, dumper.threads().size());
-  EXPECT_TRUE(dumper.ThreadsSuspend());
-
-  ThreadInfo one_thread;
-  for(size_t i = 0; i < dumper.threads().size(); ++i) {
-    EXPECT_TRUE(dumper.ThreadInfoGet(dumper.threads()[i], &one_thread));
-    // In the helper program, we stored a pointer to the thread id in a
-    // specific register. Check that we can recover its value.
-#if defined(__ARM_EABI__)
-    pid_t *process_tid_location = (pid_t *)(one_thread.regs.uregs[3]);
-#elif defined(__i386)
-    pid_t *process_tid_location = (pid_t *)(one_thread.regs.ecx);
-#elif defined(__x86_64)
-    pid_t *process_tid_location = (pid_t *)(one_thread.regs.rcx);
-#else
-#error This test has not been ported to this platform.
-#endif
-    pid_t one_thread_id;
-    dumper.CopyFromProcess(&one_thread_id,
-                           dumper.threads()[i],
-                           process_tid_location,
-                           4);
-    EXPECT_EQ(dumper.threads()[i], one_thread_id);
-  }
-  kill(child_pid, SIGKILL);
-}
-
-TEST(LinuxDumperTest, BuildProcPath) {
-  const pid_t pid = getpid();
-  LinuxDumper dumper(pid);
-
-  char maps_path[256] = "dummymappath";
-  char maps_path_expected[256];
-  snprintf(maps_path_expected, sizeof(maps_path_expected),
-           "/proc/%d/maps", pid);
-  dumper.BuildProcPath(maps_path, pid, "maps");
-  ASSERT_STREQ(maps_path, maps_path_expected);
-
-  // In release mode, we expect BuildProcPath to handle the invalid
-  // parameters correctly and fill map_path with an empty
-  // NULL-terminated string.
-#ifdef NDEBUG
-  snprintf(maps_path, sizeof(maps_path), "dummymappath");
-  dumper.BuildProcPath(maps_path, 0, "maps");
-  EXPECT_STREQ(maps_path, "");
-
-  snprintf(maps_path, sizeof(maps_path), "dummymappath");
-  dumper.BuildProcPath(maps_path, getpid(), "");
-  EXPECT_STREQ(maps_path, "");
-
-  snprintf(maps_path, sizeof(maps_path), "dummymappath");
-  dumper.BuildProcPath(maps_path, getpid(), NULL);
-  EXPECT_STREQ(maps_path, "");
-#endif
-}
-
-#if !defined(__ARM_EABI__)
-TEST(LinuxDumperTest, MappingsIncludeLinuxGate) {
-  LinuxDumper dumper(getpid());
-  ASSERT_TRUE(dumper.Init());
-
-  void* linux_gate_loc = reinterpret_cast<void *>(dumper.auxv()[AT_SYSINFO_EHDR]);
-  ASSERT_TRUE(linux_gate_loc);
-  bool found_linux_gate = false;
-
-  const wasteful_vector<MappingInfo*> mappings = dumper.mappings();
-  const MappingInfo* mapping;
-  for (unsigned i = 0; i < mappings.size(); ++i) {
-    mapping = mappings[i];
-    if (!strcmp(mapping->name, kLinuxGateLibraryName)) {
-      found_linux_gate = true;
-      break;
-    }
-  }
-  EXPECT_TRUE(found_linux_gate);
-  EXPECT_EQ(linux_gate_loc, reinterpret_cast<void*>(mapping->start_addr));
-  EXPECT_EQ(0, memcmp(linux_gate_loc, ELFMAG, SELFMAG));
-}
-#endif
-
-TEST(LinuxDumperTest, FileIDsMatch) {
-  // Calculate the File ID of our binary using both
-  // FileID::ElfFileIdentifier and LinuxDumper::ElfFileIdentifierForMapping
-  // and ensure that we get the same result from both.
-  char exe_name[PATH_MAX];
-  ssize_t len = readlink("/proc/self/exe", exe_name, PATH_MAX - 1);
-  ASSERT_NE(len, -1);
-  exe_name[len] = '\0';
-
-  int fds[2];
-  ASSERT_NE(-1, pipe(fds));
-
-  // fork a child so we can ptrace it
-  const pid_t child = fork();
-  if (child == 0) {
-    close(fds[1]);
-    // now wait forever for the parent
-    char b;
-    HANDLE_EINTR(read(fds[0], &b, sizeof(b)));
-    close(fds[0]);
-    syscall(__NR_exit);
-  }
-  close(fds[0]);
-
-  LinuxDumper dumper(child);
-  ASSERT_TRUE(dumper.Init());
-  const wasteful_vector<MappingInfo*> mappings = dumper.mappings();
-  bool found_exe = false;
-  unsigned i;
-  for (i = 0; i < mappings.size(); ++i) {
-    const MappingInfo* mapping = mappings[i];
-    if (!strcmp(mapping->name, exe_name)) {
-      found_exe = true;
-      break;
-    }
-  }
-  ASSERT_TRUE(found_exe);
-
-  uint8_t identifier1[sizeof(MDGUID)];
-  uint8_t identifier2[sizeof(MDGUID)];
-  EXPECT_TRUE(dumper.ElfFileIdentifierForMapping(*mappings[i], identifier1));
-  FileID fileid(exe_name);
-  EXPECT_TRUE(fileid.ElfFileIdentifier(identifier2));
-  char identifier_string1[37];
-  char identifier_string2[37];
-  FileID::ConvertIdentifierToString(identifier1, identifier_string1,
-                                    37);
-  FileID::ConvertIdentifierToString(identifier2, identifier_string2,
-                                    37);
-  EXPECT_STREQ(identifier_string1, identifier_string2);
-  close(fds[1]);
-}

toolkit/crashreporter/google-breakpad/src/client/linux/minidump_writer/linux_dumper_unittest_helper.cc

@@ -32,11 +32,15 @@
 // id.
 
 #include <pthread.h>
+#include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <sys/syscall.h>
 #include <unistd.h>
 
+#include "processor/scoped_ptr.h"
+#include "third_party/lss/linux_syscall_support.h"
+
 #if defined(__ARM_EABI__)
 #define TID_PTR_REGISTER "r3"
 #elif defined(__i386)
@@ -48,7 +52,14 @@
 #endif
 
 void *thread_function(void *data) {
-  volatile pid_t thread_id = syscall(SYS_gettid);
+  int pipefd = *static_cast<int *>(data);
+  volatile pid_t thread_id = syscall(__NR_gettid);
+  // Signal parent that a thread has started.
+  uint8_t byte = 1;
+  if (write(pipefd, &byte, sizeof(byte)) != sizeof(byte)) {
+    perror("ERROR: parent notification failed");
+    return NULL;
+  }
   register volatile pid_t *thread_id_ptr asm(TID_PTR_REGISTER) = &thread_id;
   while (true)
     asm volatile ("" : : "r" (thread_id_ptr));
@@ -56,18 +67,24 @@ void *thread_function(void *data) {
 }
 
 int main(int argc, char *argv[]) {
-  int num_threads = atoi(argv[1]);
+  if (argc < 3) {
+    fprintf(stderr,
+            "usage: linux_dumper_unittest_helper <pipe fd> <# of threads>\n");
+    return 1;
+  }
+  int pipefd = atoi(argv[1]);
+  int num_threads = atoi(argv[2]);
   if (num_threads < 1) {
     fprintf(stderr, "ERROR: number of threads is 0");
     return 1;
   }
-  pthread_t threads[num_threads];
+  google_breakpad::scoped_array<pthread_t> threads(new pthread_t[num_threads]);
   pthread_attr_t thread_attributes;
   pthread_attr_init(&thread_attributes);
   pthread_attr_setdetachstate(&thread_attributes, PTHREAD_CREATE_DETACHED);
   for (int i = 1; i < num_threads; i++) {
-    pthread_create(&threads[i], &thread_attributes, &thread_function, NULL);
+    pthread_create(&threads[i], &thread_attributes, &thread_function, &pipefd);
   }
-  thread_function(NULL);
+  thread_function(&pipefd);
   return 0;
 }

toolkit/crashreporter/google-breakpad/src/client/linux/minidump_writer/linux_ptrace_dumper.cc

@@ -0,0 +1,291 @@
+// Copyright (c) 2012, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// linux_ptrace_dumper.cc: Implement google_breakpad::LinuxPtraceDumper.
+// See linux_ptrace_dumper.h for detals.
+// This class was originally splitted from google_breakpad::LinuxDumper.
+
+// This code deals with the mechanics of getting information about a crashed
+// process. Since this code may run in a compromised address space, the same
+// rules apply as detailed at the top of minidump_writer.h: no libc calls and
+// use the alternative allocator.
+
+#include "client/linux/minidump_writer/linux_ptrace_dumper.h"
+
+#include <asm/ptrace.h>
+#include <assert.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <limits.h>
+#include <stddef.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/ptrace.h>
+#include <sys/wait.h>
+
+#include "client/linux/minidump_writer/directory_reader.h"
+#include "client/linux/minidump_writer/line_reader.h"
+#include "common/linux/linux_libc_support.h"
+#include "third_party/lss/linux_syscall_support.h"
+
+// Suspends a thread by attaching to it.
+static bool SuspendThread(pid_t pid) {
+  // This may fail if the thread has just died or debugged.
+  errno = 0;
+  if (sys_ptrace(PTRACE_ATTACH, pid, NULL, NULL) != 0 &&
+      errno != 0) {
+    return false;
+  }
+  while (sys_waitpid(pid, NULL, __WALL) < 0) {
+    if (errno != EINTR) {
+      sys_ptrace(PTRACE_DETACH, pid, NULL, NULL);
+      return false;
+    }
+  }
+#if defined(__i386) || defined(__x86_64)
+  // On x86, the stack pointer is NULL or -1, when executing trusted code in
+  // the seccomp sandbox. Not only does this cause difficulties down the line
+  // when trying to dump the thread's stack, it also results in the minidumps
+  // containing information about the trusted threads. This information is
+  // generally completely meaningless and just pollutes the minidumps.
+  // We thus test the stack pointer and exclude any threads that are part of
+  // the seccomp sandbox's trusted code.
+  user_regs_struct regs;
+  if (sys_ptrace(PTRACE_GETREGS, pid, NULL, &regs) == -1 ||
+#if defined(__i386)
+      !regs.esp
+#elif defined(__x86_64)
+      !regs.rsp
+#endif
+      ) {
+    sys_ptrace(PTRACE_DETACH, pid, NULL, NULL);
+    return false;
+  }
+#endif
+  return true;
+}
+
+// Resumes a thread by detaching from it.
+static bool ResumeThread(pid_t pid) {
+  return sys_ptrace(PTRACE_DETACH, pid, NULL, NULL) >= 0;
+}
+
+namespace google_breakpad {
+
+LinuxPtraceDumper::LinuxPtraceDumper(pid_t pid)
+    : LinuxDumper(pid),
+      threads_suspended_(false) {
+}
+
+bool LinuxPtraceDumper::BuildProcPath(char* path, pid_t pid,
+                                      const char* node) const {
+  if (!path || !node || pid <= 0)
+    return false;
+
+  size_t node_len = my_strlen(node);
+  if (node_len == 0)
+    return false;
+
+  const unsigned pid_len = my_uint_len(pid);
+  const size_t total_length = 6 + pid_len + 1 + node_len;
+  if (total_length >= NAME_MAX)
+    return false;
+
+  my_memcpy(path, "/proc/", 6);
+  my_uitos(path + 6, pid, pid_len);
+  path[6 + pid_len] = '/';
+  my_memcpy(path + 6 + pid_len + 1, node, node_len);
+  path[total_length] = '\0';
+  return true;
+}
+
+void LinuxPtraceDumper::CopyFromProcess(void* dest, pid_t child,
+                                        const void* src, size_t length) {
+  unsigned long tmp = 55;
+  size_t done = 0;
+  static const size_t word_size = sizeof(tmp);
+  uint8_t* const local = (uint8_t*) dest;
+  uint8_t* const remote = (uint8_t*) src;
+
+  while (done < length) {
+    const size_t l = (length - done > word_size) ? word_size : (length - done);
+    if (sys_ptrace(PTRACE_PEEKDATA, child, remote + done, &tmp) == -1) {
+      tmp = 0;
+    }
+    my_memcpy(local + done, &tmp, l);
+    done += l;
+  }
+}
+
+// Read thread info from /proc/$pid/status.
+// Fill out the |tgid|, |ppid| and |pid| members of |info|. If unavailable,
+// these members are set to -1. Returns true iff all three members are
+// available.
+bool LinuxPtraceDumper::GetThreadInfoByIndex(size_t index, ThreadInfo* info) {
+  if (index >= threads_.size())
+    return false;
+
+  pid_t tid = threads_[index];
+
+  assert(info != NULL);
+  char status_path[NAME_MAX];
+  if (!BuildProcPath(status_path, tid, "status"))
+    return false;
+
+  const int fd = sys_open(status_path, O_RDONLY, 0);
+  if (fd < 0)
+    return false;
+
+  LineReader* const line_reader = new(allocator_) LineReader(fd);
+  const char* line;
+  unsigned line_len;
+
+  info->ppid = info->tgid = -1;
+
+  while (line_reader->GetNextLine(&line, &line_len)) {
+    if (my_strncmp("Tgid:\t", line, 6) == 0) {
+      my_strtoui(&info->tgid, line + 6);
+    } else if (my_strncmp("PPid:\t", line, 6) == 0) {
+      my_strtoui(&info->ppid, line + 6);
+    }
+
+    line_reader->PopLine(line_len);
+  }
+  sys_close(fd);
+
+  if (info->ppid == -1 || info->tgid == -1)
+    return false;
+
+  if (sys_ptrace(PTRACE_GETREGS, tid, NULL, &info->regs) == -1) {
+    return false;
+  }
+
+  if (sys_ptrace(PTRACE_GETFPREGS, tid, NULL, &info->fpregs) == -1) {
+    return false;
+  }
+
+#if defined(__i386)
+  if (sys_ptrace(PTRACE_GETFPXREGS, tid, NULL, &info->fpxregs) == -1)
+    return false;
+#endif
+
+#if defined(__i386) || defined(__x86_64)
+  for (unsigned i = 0; i < ThreadInfo::kNumDebugRegisters; ++i) {
+    if (sys_ptrace(
+        PTRACE_PEEKUSER, tid,
+        reinterpret_cast<void*> (offsetof(struct user,
+                                          u_debugreg[0]) + i *
+                                 sizeof(debugreg_t)),
+        &info->dregs[i]) == -1) {
+      return false;
+    }
+  }
+#endif
+
+  const uint8_t* stack_pointer;
+#if defined(__i386)
+  my_memcpy(&stack_pointer, &info->regs.esp, sizeof(info->regs.esp));
+#elif defined(__x86_64)
+  my_memcpy(&stack_pointer, &info->regs.rsp, sizeof(info->regs.rsp));
+#elif defined(__ARM_EABI__)
+  my_memcpy(&stack_pointer, &info->regs.ARM_sp, sizeof(info->regs.ARM_sp));
+#else
+#error "This code hasn't been ported to your platform yet."
+#endif
+
+  return GetStackInfo(&info->stack, &info->stack_len,
+                      (uintptr_t) stack_pointer);
+}
+
+bool LinuxPtraceDumper::IsPostMortem() const {
+  return false;
+}
+
+bool LinuxPtraceDumper::ThreadsSuspend() {
+  if (threads_suspended_)
+    return true;
+  for (size_t i = 0; i < threads_.size(); ++i) {
+    if (!SuspendThread(threads_[i])) {
+      // If the thread either disappeared before we could attach to it, or if
+      // it was part of the seccomp sandbox's trusted code, it is OK to
+      // silently drop it from the minidump.
+      my_memmove(&threads_[i], &threads_[i+1],
+                 (threads_.size() - i - 1) * sizeof(threads_[i]));
+      threads_.resize(threads_.size() - 1);
+      --i;
+    }
+  }
+  threads_suspended_ = true;
+  return threads_.size() > 0;
+}
+
+bool LinuxPtraceDumper::ThreadsResume() {
+  if (!threads_suspended_)
+    return false;
+  bool good = true;
+  for (size_t i = 0; i < threads_.size(); ++i)
+    good &= ResumeThread(threads_[i]);
+  threads_suspended_ = false;
+  return good;
+}
+
+// Parse /proc/$pid/task to list all the threads of the process identified by
+// pid.
+bool LinuxPtraceDumper::EnumerateThreads() {
+  char task_path[NAME_MAX];
+  if (!BuildProcPath(task_path, pid_, "task"))
+    return false;
+
+  const int fd = sys_open(task_path, O_RDONLY | O_DIRECTORY, 0);
+  if (fd < 0)
+    return false;
+  DirectoryReader* dir_reader = new(allocator_) DirectoryReader(fd);
+
+  // The directory may contain duplicate entries which we filter by assuming
+  // that they are consecutive.
+  int last_tid = -1;
+  const char* dent_name;
+  while (dir_reader->GetNextEntry(&dent_name)) {
+    if (my_strcmp(dent_name, ".") &&
+        my_strcmp(dent_name, "..")) {
+      int tid = 0;
+      if (my_strtoui(&tid, dent_name) &&
+          last_tid != tid) {
+        last_tid = tid;
+        threads_.push_back(tid);
+      }
+    }
+    dir_reader->PopEntry();
+  }
+
+  sys_close(fd);
+  return true;
+}
+
+}  // namespace google_breakpad

toolkit/crashreporter/google-breakpad/src/client/linux/minidump_writer/linux_ptrace_dumper.h

@@ -0,0 +1,92 @@
+// Copyright (c) 2012, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// linux_ptrace_dumper.h: Define the google_breakpad::LinuxPtraceDumper
+// class, which is derived from google_breakpad::LinuxDumper to extract
+// information from a crashed process via ptrace.
+// This class was originally splitted from google_breakpad::LinuxDumper.
+
+#ifndef CLIENT_LINUX_MINIDUMP_WRITER_LINUX_PTRACE_DUMPER_H_
+#define CLIENT_LINUX_MINIDUMP_WRITER_LINUX_PTRACE_DUMPER_H_
+
+#include "client/linux/minidump_writer/linux_dumper.h"
+
+namespace google_breakpad {
+
+class LinuxPtraceDumper : public LinuxDumper {
+ public:
+  // Constructs a dumper for extracting information of a given process
+  // with a process ID of |pid|.
+  explicit LinuxPtraceDumper(pid_t pid);
+
+  // Implements LinuxDumper::BuildProcPath().
+  // Builds a proc path for a certain pid for a node (/proc/<pid>/<node>).
+  // |path| is a character array of at least NAME_MAX bytes to return the
+  // result. |node| is the final node without any slashes. Returns true on
+  // success.
+  virtual bool BuildProcPath(char* path, pid_t pid, const char* node) const;
+
+  // Implements LinuxDumper::CopyFromProcess().
+  // Copies content of |length| bytes from a given process |child|,
+  // starting from |src|, into |dest|. This method uses ptrace to extract
+  // the content from the target process.
+  virtual void CopyFromProcess(void* dest, pid_t child, const void* src,
+                               size_t length);
+
+  // Implements LinuxDumper::GetThreadInfoByIndex().
+  // Reads information about the |index|-th thread of |threads_|.
+  // Returns true on success. One must have called |ThreadsSuspend| first.
+  virtual bool GetThreadInfoByIndex(size_t index, ThreadInfo* info);
+
+  // Implements LinuxDumper::IsPostMortem().
+  // Always returns false to indicate this dumper performs a dump of
+  // a crashed process via ptrace.
+  virtual bool IsPostMortem() const;
+
+  // Implements LinuxDumper::ThreadsSuspend().
+  // Suspends all threads in the given process. Returns true on success.
+  virtual bool ThreadsSuspend();
+
+  // Implements LinuxDumper::ThreadsResume().
+  // Resumes all threads in the given process. Returns true on success.
+  virtual bool ThreadsResume();
+
+ protected:
+  // Implements LinuxDumper::EnumerateThreads().
+  // Enumerates all threads of the given process into |threads_|.
+  virtual bool EnumerateThreads();
+
+ private:
+  // Set to true if all threads of the crashed process are suspended.
+  bool threads_suspended_;
+};
+
+}  // namespace google_breakpad
+
+#endif  // CLIENT_LINUX_HANDLER_LINUX_PTRACE_DUMPER_H_

toolkit/crashreporter/google-breakpad/src/client/linux/minidump_writer/linux_ptrace_dumper_unittest.cc

@@ -0,0 +1,434 @@
+// Copyright (c) 2009, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// linux_ptrace_dumper_unittest.cc:
+// Unit tests for google_breakpad::LinuxPtraceDumoer.
+//
+// This file was renamed from linux_dumper_unittest.cc and modified due
+// to LinuxDumper being splitted into two classes.
+
+#include <errno.h>
+#include <fcntl.h>
+#include <limits.h>
+#include <unistd.h>
+#include <signal.h>
+#include <stdint.h>
+#include <string.h>
+#include <sys/mman.h>
+#include <sys/poll.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+
+#include <string>
+
+#include "breakpad_googletest_includes.h"
+#include "client/linux/minidump_writer/linux_ptrace_dumper.h"
+#include "client/linux/minidump_writer/minidump_writer_unittest_utils.h"
+#include "common/linux/eintr_wrapper.h"
+#include "common/linux/file_id.h"
+#include "common/linux/ignore_ret.h"
+#include "common/linux/safe_readlink.h"
+#include "common/memory.h"
+#include "common/using_std_string.h"
+
+using namespace google_breakpad;
+
+namespace {
+
+typedef testing::Test LinuxPtraceDumperTest;
+
+}  // namespace
+
+TEST(LinuxPtraceDumperTest, Setup) {
+  LinuxPtraceDumper dumper(getpid());
+}
+
+TEST(LinuxPtraceDumperTest, FindMappings) {
+  LinuxPtraceDumper dumper(getpid());
+  ASSERT_TRUE(dumper.Init());
+
+  ASSERT_TRUE(dumper.FindMapping(reinterpret_cast<void*>(getpid)));
+  ASSERT_TRUE(dumper.FindMapping(reinterpret_cast<void*>(printf)));
+  ASSERT_FALSE(dumper.FindMapping(NULL));
+}
+
+TEST(LinuxPtraceDumperTest, ThreadList) {
+  LinuxPtraceDumper dumper(getpid());
+  ASSERT_TRUE(dumper.Init());
+
+  ASSERT_GE(dumper.threads().size(), (size_t)1);
+  bool found = false;
+  for (size_t i = 0; i < dumper.threads().size(); ++i) {
+    if (dumper.threads()[i] == getpid()) {
+      found = true;
+      break;
+    }
+  }
+}
+
+// Helper stack class to close a file descriptor and unmap
+// a mmap'ed mapping.
+class StackHelper {
+ public:
+  StackHelper(int fd, char* mapping, size_t size)
+    : fd_(fd), mapping_(mapping), size_(size) {}
+  ~StackHelper() {
+    munmap(mapping_, size_);
+    close(fd_);
+  }
+
+ private:
+  int fd_;
+  char* mapping_;
+  size_t size_;
+};
+
+TEST(LinuxPtraceDumperTest, MergedMappings) {
+  string helper_path(GetHelperBinary());
+  if (helper_path.empty()) {
+    FAIL() << "Couldn't find helper binary";
+    exit(1);
+  }
+
+  // mmap two segments out of the helper binary, one
+  // enclosed in the other, but with different protections.
+  const size_t kPageSize = sysconf(_SC_PAGESIZE);
+  const size_t kMappingSize = 3 * kPageSize;
+  int fd = open(helper_path.c_str(), O_RDONLY);
+  ASSERT_NE(-1, fd) << "Failed to open file: " << helper_path
+                    << ", Error: " << strerror(errno);
+  char* mapping =
+    reinterpret_cast<char*>(mmap(NULL,
+                                 kMappingSize,
+                                 PROT_READ,
+                                 MAP_SHARED,
+                                 fd,
+                                 0));
+  ASSERT_TRUE(mapping);
+
+  const uintptr_t kMappingAddress = reinterpret_cast<uintptr_t>(mapping);
+
+  // Ensure that things get cleaned up.
+  StackHelper helper(fd, mapping, kMappingSize);
+
+  // Carve a page out of the first mapping with different permissions.
+  char* inside_mapping =  reinterpret_cast<char*>(
+      mmap(mapping + 2 *kPageSize,
+           kPageSize,
+           PROT_NONE,
+           MAP_SHARED | MAP_FIXED,
+           fd,
+           // Map a different offset just to
+           // better test real-world conditions.
+           kPageSize));
+  ASSERT_TRUE(inside_mapping);
+
+  // Now check that LinuxPtraceDumper interpreted the mappings properly.
+  LinuxPtraceDumper dumper(getpid());
+  ASSERT_TRUE(dumper.Init());
+  int mapping_count = 0;
+  for (unsigned i = 0; i < dumper.mappings().size(); ++i) {
+    const MappingInfo& mapping = *dumper.mappings()[i];
+    if (strcmp(mapping.name, helper_path.c_str()) == 0) {
+      // This mapping should encompass the entire original mapped
+      // range.
+      EXPECT_EQ(kMappingAddress, mapping.start_addr);
+      EXPECT_EQ(kMappingSize, mapping.size);
+      EXPECT_EQ(0, mapping.offset);
+      mapping_count++;
+    }
+  }
+  EXPECT_EQ(1, mapping_count);
+}
+
+TEST(LinuxPtraceDumperTest, VerifyStackReadWithMultipleThreads) {
+  static const int kNumberOfThreadsInHelperProgram = 5;
+  char kNumberOfThreadsArgument[2];
+  sprintf(kNumberOfThreadsArgument, "%d", kNumberOfThreadsInHelperProgram);
+
+  int fds[2];
+  ASSERT_NE(-1, pipe(fds));
+
+  pid_t child_pid = fork();
+  if (child_pid == 0) {
+    // In child process.
+    close(fds[0]);
+
+    string helper_path(GetHelperBinary());
+    if (helper_path.empty()) {
+      FAIL() << "Couldn't find helper binary";
+      exit(1);
+    }
+
+    // Pass the pipe fd and the number of threads as arguments.
+    char pipe_fd_string[8];
+    sprintf(pipe_fd_string, "%d", fds[1]);
+    execl(helper_path.c_str(),
+          "linux_dumper_unittest_helper",
+          pipe_fd_string,
+          kNumberOfThreadsArgument,
+          NULL);
+    // Kill if we get here.
+    printf("Errno from exec: %d", errno);
+    FAIL() << "Exec of " << helper_path << " failed: " << strerror(errno);
+    exit(0);
+  }
+  close(fds[1]);
+
+  // Wait for all child threads to indicate that they have started
+  for (int threads = 0; threads < kNumberOfThreadsInHelperProgram; threads++) {
+    struct pollfd pfd;
+    memset(&pfd, 0, sizeof(pfd));
+    pfd.fd = fds[0];
+    pfd.events = POLLIN | POLLERR;
+
+    const int r = HANDLE_EINTR(poll(&pfd, 1, 1000));
+    ASSERT_EQ(1, r);
+    ASSERT_TRUE(pfd.revents & POLLIN);
+    uint8_t junk;
+    ASSERT_EQ(read(fds[0], &junk, sizeof(junk)), sizeof(junk));
+  }
+  close(fds[0]);
+
+  // There is a race here because we may stop a child thread before
+  // it is actually running the busy loop. Empirically this sleep
+  // is sufficient to avoid the race.
+  usleep(100000);
+
+  // Children are ready now.
+  LinuxPtraceDumper dumper(child_pid);
+  ASSERT_TRUE(dumper.Init());
+  EXPECT_EQ((size_t)kNumberOfThreadsInHelperProgram, dumper.threads().size());
+  EXPECT_TRUE(dumper.ThreadsSuspend());
+
+  ThreadInfo one_thread;
+  for (size_t i = 0; i < dumper.threads().size(); ++i) {
+    EXPECT_TRUE(dumper.GetThreadInfoByIndex(i, &one_thread));
+    // In the helper program, we stored a pointer to the thread id in a
+    // specific register. Check that we can recover its value.
+#if defined(__ARM_EABI__)
+    pid_t *process_tid_location = (pid_t *)(one_thread.regs.uregs[3]);
+#elif defined(__i386)
+    pid_t *process_tid_location = (pid_t *)(one_thread.regs.ecx);
+#elif defined(__x86_64)
+    pid_t *process_tid_location = (pid_t *)(one_thread.regs.rcx);
+#else
+#error This test has not been ported to this platform.
+#endif
+    pid_t one_thread_id;
+    dumper.CopyFromProcess(&one_thread_id,
+                           dumper.threads()[i],
+                           process_tid_location,
+                           4);
+    EXPECT_EQ(dumper.threads()[i], one_thread_id);
+  }
+  EXPECT_TRUE(dumper.ThreadsResume());
+  kill(child_pid, SIGKILL);
+
+  // Reap child
+  int status;
+  ASSERT_NE(-1, HANDLE_EINTR(waitpid(child_pid, &status, 0)));
+  ASSERT_TRUE(WIFSIGNALED(status));
+  ASSERT_EQ(SIGKILL, WTERMSIG(status));
+}
+
+TEST(LinuxPtraceDumperTest, BuildProcPath) {
+  const pid_t pid = getpid();
+  LinuxPtraceDumper dumper(pid);
+
+  char maps_path[NAME_MAX] = "";
+  char maps_path_expected[NAME_MAX];
+  snprintf(maps_path_expected, sizeof(maps_path_expected),
+           "/proc/%d/maps", pid);
+  EXPECT_TRUE(dumper.BuildProcPath(maps_path, pid, "maps"));
+  EXPECT_STREQ(maps_path_expected, maps_path);
+
+  EXPECT_FALSE(dumper.BuildProcPath(NULL, pid, "maps"));
+  EXPECT_FALSE(dumper.BuildProcPath(maps_path, 0, "maps"));
+  EXPECT_FALSE(dumper.BuildProcPath(maps_path, pid, ""));
+  EXPECT_FALSE(dumper.BuildProcPath(maps_path, pid, NULL));
+
+  char long_node[NAME_MAX];
+  size_t long_node_len = NAME_MAX - strlen("/proc/123") - 1;
+  memset(long_node, 'a', long_node_len);
+  long_node[long_node_len] = '\0';
+  EXPECT_FALSE(dumper.BuildProcPath(maps_path, 123, long_node));
+}
+
+#if !defined(__ARM_EABI__)
+// Ensure that the linux-gate VDSO is included in the mapping list.
+TEST(LinuxPtraceDumperTest, MappingsIncludeLinuxGate) {
+  LinuxPtraceDumper dumper(getpid());
+  ASSERT_TRUE(dumper.Init());
+
+  void* linux_gate_loc =
+    reinterpret_cast<void *>(dumper.auxv()[AT_SYSINFO_EHDR]);
+  ASSERT_TRUE(linux_gate_loc);
+  bool found_linux_gate = false;
+
+  const wasteful_vector<MappingInfo*> mappings = dumper.mappings();
+  const MappingInfo* mapping;
+  for (unsigned i = 0; i < mappings.size(); ++i) {
+    mapping = mappings[i];
+    if (!strcmp(mapping->name, kLinuxGateLibraryName)) {
+      found_linux_gate = true;
+      break;
+    }
+  }
+  EXPECT_TRUE(found_linux_gate);
+  EXPECT_EQ(linux_gate_loc, reinterpret_cast<void*>(mapping->start_addr));
+  EXPECT_EQ(0, memcmp(linux_gate_loc, ELFMAG, SELFMAG));
+}
+
+// Ensure that the linux-gate VDSO can generate a non-zeroed File ID.
+TEST(LinuxPtraceDumperTest, LinuxGateMappingID) {
+  LinuxPtraceDumper dumper(getpid());
+  ASSERT_TRUE(dumper.Init());
+
+  bool found_linux_gate = false;
+  const wasteful_vector<MappingInfo*> mappings = dumper.mappings();
+  unsigned index = 0;
+  for (unsigned i = 0; i < mappings.size(); ++i) {
+    if (!strcmp(mappings[i]->name, kLinuxGateLibraryName)) {
+      found_linux_gate = true;
+      index = i;
+      break;
+    }
+  }
+  ASSERT_TRUE(found_linux_gate);
+
+  uint8_t identifier[sizeof(MDGUID)];
+  ASSERT_TRUE(dumper.ElfFileIdentifierForMapping(*mappings[index],
+                                                 true,
+                                                 index,
+                                                 identifier));
+  uint8_t empty_identifier[sizeof(MDGUID)];
+  memset(empty_identifier, 0, sizeof(empty_identifier));
+  EXPECT_NE(0, memcmp(empty_identifier, identifier, sizeof(identifier)));
+}
+
+// Ensure that the linux-gate VDSO can generate a non-zeroed File ID
+// from a child process.
+TEST(LinuxPtraceDumperTest, LinuxGateMappingIDChild) {
+  int fds[2];
+  ASSERT_NE(-1, pipe(fds));
+
+  // Fork a child so ptrace works.
+  const pid_t child = fork();
+  if (child == 0) {
+    close(fds[1]);
+    // Now wait forever for the parent.
+    char b;
+    IGNORE_RET(HANDLE_EINTR(read(fds[0], &b, sizeof(b))));
+    close(fds[0]);
+    syscall(__NR_exit);
+  }
+  close(fds[0]);
+
+  LinuxPtraceDumper dumper(child);
+  ASSERT_TRUE(dumper.Init());
+
+  bool found_linux_gate = false;
+  const wasteful_vector<MappingInfo*> mappings = dumper.mappings();
+  unsigned index = 0;
+  for (unsigned i = 0; i < mappings.size(); ++i) {
+    if (!strcmp(mappings[i]->name, kLinuxGateLibraryName)) {
+      found_linux_gate = true;
+      index = i;
+      break;
+    }
+  }
+  ASSERT_TRUE(found_linux_gate);
+
+  // Need to suspend the child so ptrace actually works.
+  ASSERT_TRUE(dumper.ThreadsSuspend());
+  uint8_t identifier[sizeof(MDGUID)];
+  ASSERT_TRUE(dumper.ElfFileIdentifierForMapping(*mappings[index],
+                                                 true,
+                                                 index,
+                                                 identifier));
+  uint8_t empty_identifier[sizeof(MDGUID)];
+  memset(empty_identifier, 0, sizeof(empty_identifier));
+  EXPECT_NE(0, memcmp(empty_identifier, identifier, sizeof(identifier)));
+  EXPECT_TRUE(dumper.ThreadsResume());
+  close(fds[1]);
+}
+#endif
+
+TEST(LinuxPtraceDumperTest, FileIDsMatch) {
+  // Calculate the File ID of our binary using both
+  // FileID::ElfFileIdentifier and LinuxDumper::ElfFileIdentifierForMapping
+  // and ensure that we get the same result from both.
+  char exe_name[PATH_MAX];
+  ASSERT_TRUE(SafeReadLink("/proc/self/exe", exe_name));
+
+  int fds[2];
+  ASSERT_NE(-1, pipe(fds));
+
+  // Fork a child so ptrace works.
+  const pid_t child = fork();
+  if (child == 0) {
+    close(fds[1]);
+    // Now wait forever for the parent.
+    char b;
+    IGNORE_RET(HANDLE_EINTR(read(fds[0], &b, sizeof(b))));
+    close(fds[0]);
+    syscall(__NR_exit);
+  }
+  close(fds[0]);
+
+  LinuxPtraceDumper dumper(child);
+  ASSERT_TRUE(dumper.Init());
+  const wasteful_vector<MappingInfo*> mappings = dumper.mappings();
+  bool found_exe = false;
+  unsigned i;
+  for (i = 0; i < mappings.size(); ++i) {
+    const MappingInfo* mapping = mappings[i];
+    if (!strcmp(mapping->name, exe_name)) {
+      found_exe = true;
+      break;
+    }
+  }
+  ASSERT_TRUE(found_exe);
+
+  uint8_t identifier1[sizeof(MDGUID)];
+  uint8_t identifier2[sizeof(MDGUID)];
+  EXPECT_TRUE(dumper.ElfFileIdentifierForMapping(*mappings[i], true, i,
+                                                 identifier1));
+  FileID fileid(exe_name);
+  EXPECT_TRUE(fileid.ElfFileIdentifier(identifier2));
+  char identifier_string1[37];
+  char identifier_string2[37];
+  FileID::ConvertIdentifierToString(identifier1, identifier_string1,
+                                    37);
+  FileID::ConvertIdentifierToString(identifier2, identifier_string2,
+                                    37);
+  EXPECT_STREQ(identifier_string1, identifier_string2);
+  close(fds[1]);
+}

toolkit/crashreporter/google-breakpad/src/client/linux/minidump_writer/minidump_writer.h

@@ -30,41 +30,57 @@
 #ifndef CLIENT_LINUX_MINIDUMP_WRITER_MINIDUMP_WRITER_H_
 #define CLIENT_LINUX_MINIDUMP_WRITER_MINIDUMP_WRITER_H_
 
-#include <list>
-#include <utility>
-
 #include <stdint.h>
 #include <unistd.h>
 
+#include <list>
+#include <utility>
+
+#include "client/linux/minidump_writer/linux_dumper.h"
 #include "google_breakpad/common/minidump_format.h"
 
 namespace google_breakpad {
 
+class ExceptionHandler;
+
+struct MappingEntry {
+  MappingInfo first;
+  u_int8_t second[sizeof(MDGUID)];
+};
+
 // A list of <MappingInfo, GUID>
-typedef std::pair<struct MappingInfo, u_int8_t[sizeof(MDGUID)]> MappingEntry;
 typedef std::list<MappingEntry> MappingList;
 
 // These entries store a list of memory regions that the client wants included
 // in the minidump.
 struct AppMemory {
-  AppMemory(void *ptr, size_t length) : ptr(ptr), length(length) {}
-
-  void *ptr;
+  void* ptr;
   size_t length;
+
+  bool operator==(const struct AppMemory& other) const {
+    return ptr == other.ptr;
+  }
+
+  bool operator==(const void* other) const {
+    return ptr == other;
+  }
 };
 typedef std::list<AppMemory> AppMemoryList;
 
-// Write a minidump to the filesystem. This function does not malloc nor use
+// Writes a minidump to the filesystem. These functions do not malloc nor use
 // libc functions which may. Thus, it can be used in contexts where the state
 // of the heap may be corrupt.
-//   filename: the filename to write to. This is opened O_EXCL and fails if
-//     open fails.
+//   minidump_path: the path to the file to write to. This is opened O_EXCL and
+//     fails open fails.
 //   crashing_process: the pid of the crashing process. This must be trusted.
 //   blob: a blob of data from the crashing process. See exception_handler.h
 //   blob_size: the length of |blob|, in bytes
 //
 // Returns true iff successful.
-bool WriteMinidump(const char* filename, pid_t crashing_process,
+bool WriteMinidump(const char* minidump_path, pid_t crashing_process,
+                   const void* blob, size_t blob_size);
+// Same as above but takes an open file descriptor instead of a path.
+bool WriteMinidump(int minidump_fd, pid_t crashing_process,
                    const void* blob, size_t blob_size);
 
 // Alternate form of WriteMinidump() that works with processes that
@@ -72,16 +88,25 @@ bool WriteMinidump(const char* filename, pid_t crashing_process,
 // meaningful, it will be the one from which a crash signature is
 // extracted.  It is not expected that this function will be called
 // from a compromised context, but it is safe to do so.
-bool WriteMinidump(const char* filename, pid_t process,
+bool WriteMinidump(const char* minidump_path, pid_t process,
                    pid_t process_blamed_thread);
 
-// This overload also allows passing a list of known mappings and
+// These overloads also allow passing a list of known mappings and
 // a list of additional memory regions to be included in the minidump.
-bool WriteMinidump(const char* filename, pid_t crashing_process,
+bool WriteMinidump(const char* minidump_path, pid_t crashing_process,
+                   const void* blob, size_t blob_size,
+                   const MappingList& mappings,
+                   const AppMemoryList& appdata);
+bool WriteMinidump(int minidump_fd, pid_t crashing_process,
                    const void* blob, size_t blob_size,
                    const MappingList& mappings,
                    const AppMemoryList& appdata);
 
+bool WriteMinidump(const char* filename,
+                   const MappingList& mappings,
+                   const AppMemoryList& appdata,
+                   LinuxDumper* dumper);
+
 }  // namespace google_breakpad
 
 #endif  // CLIENT_LINUX_MINIDUMP_WRITER_MINIDUMP_WRITER_H_

toolkit/crashreporter/google-breakpad/src/client/linux/minidump_writer/minidump_writer_unittest.cc

@@ -1,4 +1,4 @@
-// Copyright (c) 2010 Google Inc.
+// Copyright (c) 2011 Google Inc.
 // All rights reserved.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -27,21 +27,72 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-#include <unistd.h>
+#include <fcntl.h>
+#include <sys/poll.h>
+#include <sys/stat.h>
 #include <sys/syscall.h>
+#include <sys/types.h>
+#include <ucontext.h>
+#include <unistd.h>
+#include <ucontext.h>
+
+#include <string>
 
-#include "client/linux/handler/exception_handler.h"
-#include "client/linux/minidump_writer/minidump_writer.h"
-#include "common/linux/eintr_wrapper.h"
 #include "breakpad_googletest_includes.h"
+#include "client/linux/handler/exception_handler.h"
+#include "client/linux/minidump_writer/linux_dumper.h"
+#include "client/linux/minidump_writer/minidump_writer.h"
+#include "client/linux/minidump_writer/minidump_writer_unittest_utils.h"
+#include "common/linux/eintr_wrapper.h"
+#include "common/linux/file_id.h"
+#include "common/linux/ignore_ret.h"
+#include "common/linux/safe_readlink.h"
+#include "common/tests/auto_tempdir.h"
+#include "common/tests/file_utils.h"
+#include "common/using_std_string.h"
+#include "google_breakpad/processor/minidump.h"
+#include "processor/scoped_ptr.h"
 
 using namespace google_breakpad;
 
+// Length of a formatted GUID string =
+// sizeof(MDGUID) * 2 + 4 (for dashes) + 1 (null terminator)
+const int kGUIDStringSize = 37;
+
 namespace {
 typedef testing::Test MinidumpWriterTest;
 }
 
-TEST(MinidumpWriterTest, Setup) {
+TEST(MinidumpWriterTest, SetupWithPath) {
+  int fds[2];
+  ASSERT_NE(-1, pipe(fds));
+
+  const pid_t child = fork();
+  if (child == 0) {
+    close(fds[1]);
+    char b;
+    IGNORE_RET(HANDLE_EINTR(read(fds[0], &b, sizeof(b))));
+    close(fds[0]);
+    syscall(__NR_exit);
+  }
+  close(fds[0]);
+
+  ExceptionHandler::CrashContext context;
+  memset(&context, 0, sizeof(context));
+
+  AutoTempDir temp_dir;
+  string templ = temp_dir.path() + "/minidump-writer-unittest";
+  // Set a non-zero tid to avoid tripping asserts.
+  context.tid = 1;
+  ASSERT_TRUE(WriteMinidump(templ.c_str(), child, &context, sizeof(context)));
+  struct stat st;
+  ASSERT_EQ(stat(templ.c_str(), &st), 0);
+  ASSERT_GT(st.st_size, 0u);
+
+  close(fds[1]);
+}
+
+TEST(MinidumpWriterTest, SetupWithFD) {
   int fds[2];
   ASSERT_NE(-1, pipe(fds));
 
@@ -58,13 +109,15 @@ TEST(MinidumpWriterTest, Setup) {
   ExceptionHandler::CrashContext context;
   memset(&context, 0, sizeof(context));
 
-  char templ[] = "/tmp/minidump-writer-unittest-XXXXXX";
-  mktemp(templ);
-  ASSERT_TRUE(WriteMinidump(templ, child, &context, sizeof(context)));
+  AutoTempDir temp_dir;
+  string templ = temp_dir.path() + "/minidump-writer-unittest";
+  int fd = open(templ.c_str(), O_CREAT | O_WRONLY, S_IRWXU);
+  // Set a non-zero tid to avoid tripping asserts.
+  context.tid = 1;
+  ASSERT_TRUE(WriteMinidump(fd, child, &context, sizeof(context)));
   struct stat st;
-  ASSERT_EQ(stat(templ, &st), 0);
+  ASSERT_EQ(stat(templ.c_str(), &st), 0);
   ASSERT_GT(st.st_size, 0u);
-  unlink(templ);
 
   close(fds[1]);
 }
@@ -77,13 +130,13 @@ TEST(MinidumpWriterTest, MappingInfo) {
 
   // These are defined here so the parent can use them to check the
   // data from the minidump afterwards.
-  const u_int32_t kMemorySize = sysconf(_SC_PAGESIZE);
+  const u_int32_t memory_size = sysconf(_SC_PAGESIZE);
   const char* kMemoryName = "a fake module";
   const u_int8_t kModuleGUID[sizeof(MDGUID)] = {
     0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
     0x88, 0x99, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF
   };
-  char module_identifier_buffer[37];
+  char module_identifier_buffer[kGUIDStringSize];
   FileID::ConvertIdentifierToString(kModuleGUID,
                                     module_identifier_buffer,
                                     sizeof(module_identifier_buffer));
@@ -96,23 +149,23 @@ TEST(MinidumpWriterTest, MappingInfo) {
   // And append a zero, because module IDs include an "age" field
   // which is always zero on Linux.
   module_identifier += "0";
-  
+
   // Get some memory.
   char* memory =
     reinterpret_cast<char*>(mmap(NULL,
-                                 kMemorySize,
+                                 memory_size,
                                  PROT_READ | PROT_WRITE,
                                  MAP_PRIVATE | MAP_ANON,
                                  -1,
                                  0));
-  const u_int64_t kMemoryAddress = reinterpret_cast<u_int64_t>(memory);
+  const uintptr_t kMemoryAddress = reinterpret_cast<uintptr_t>(memory);
   ASSERT_TRUE(memory);
 
   const pid_t child = fork();
   if (child == 0) {
     close(fds[1]);
     char b;
-    HANDLE_EINTR(read(fds[0], &b, sizeof(b)));
+    IGNORE_RET(HANDLE_EINTR(read(fds[0], &b, sizeof(b))));
     close(fds[0]);
     syscall(__NR_exit);
   }
@@ -120,28 +173,32 @@ TEST(MinidumpWriterTest, MappingInfo) {
 
   ExceptionHandler::CrashContext context;
   memset(&context, 0, sizeof(context));
+  ASSERT_EQ(0, getcontext(&context.context));
+  context.tid = child;
 
-  char templ[] = TEMPDIR "/minidump-writer-unittest-XXXXXX";
-  mktemp(templ);
+  AutoTempDir temp_dir;
+  string templ = temp_dir.path() + "/minidump-writer-unittest";
 
   // Add information about the mapped memory.
   MappingInfo info;
   info.start_addr = kMemoryAddress;
-  info.size = kMemorySize;
+  info.size = memory_size;
   info.offset = 0;
   strcpy(info.name, kMemoryName);
-  
+
   MappingList mappings;
-  std::pair<MappingInfo, u_int8_t[sizeof(MDGUID)]> mapping;
+  AppMemoryList memory_list;
+  MappingEntry mapping;
   mapping.first = info;
   memcpy(mapping.second, kModuleGUID, sizeof(MDGUID));
   mappings.push_back(mapping);
-  ASSERT_TRUE(WriteMinidump(templ, child, &context, sizeof(context), mappings));
+  ASSERT_TRUE(WriteMinidump(templ.c_str(), child, &context, sizeof(context),
+                            mappings, memory_list));
 
   // Read the minidump. Load the module list, and ensure that
   // the mmap'ed |memory| is listed with the given module name
   // and debug ID.
-  Minidump minidump(templ);
+  Minidump minidump(templ.c_str());
   ASSERT_TRUE(minidump.Read());
 
   MinidumpModuleList* module_list = minidump.GetModuleList();
@@ -151,11 +208,24 @@ TEST(MinidumpWriterTest, MappingInfo) {
   ASSERT_TRUE(module);
 
   EXPECT_EQ(kMemoryAddress, module->base_address());
-  EXPECT_EQ(kMemorySize, module->size());
+  EXPECT_EQ(memory_size, module->size());
   EXPECT_EQ(kMemoryName, module->code_file());
   EXPECT_EQ(module_identifier, module->debug_identifier());
 
-  unlink(templ);
+  u_int32_t len;
+  // These streams are expected to be there
+  EXPECT_TRUE(minidump.SeekToStreamType(MD_THREAD_LIST_STREAM, &len));
+  EXPECT_TRUE(minidump.SeekToStreamType(MD_MEMORY_LIST_STREAM, &len));
+  EXPECT_TRUE(minidump.SeekToStreamType(MD_EXCEPTION_STREAM, &len));
+  EXPECT_TRUE(minidump.SeekToStreamType(MD_SYSTEM_INFO_STREAM, &len));
+  EXPECT_TRUE(minidump.SeekToStreamType(MD_LINUX_CPU_INFO, &len));
+  EXPECT_TRUE(minidump.SeekToStreamType(MD_LINUX_PROC_STATUS, &len));
+  EXPECT_TRUE(minidump.SeekToStreamType(MD_LINUX_CMD_LINE, &len));
+  EXPECT_TRUE(minidump.SeekToStreamType(MD_LINUX_ENVIRON, &len));
+  EXPECT_TRUE(minidump.SeekToStreamType(MD_LINUX_AUXV, &len));
+  EXPECT_TRUE(minidump.SeekToStreamType(MD_LINUX_MAPS, &len));
+  EXPECT_TRUE(minidump.SeekToStreamType(MD_LINUX_DSO_DEBUG, &len));
+
   close(fds[1]);
 }
 
@@ -168,13 +238,13 @@ TEST(MinidumpWriterTest, MappingInfoContained) {
 
   // These are defined here so the parent can use them to check the
   // data from the minidump afterwards.
-  const u_int32_t kMemorySize = sysconf(_SC_PAGESIZE);
+  const u_int32_t memory_size = sysconf(_SC_PAGESIZE);
   const char* kMemoryName = "a fake module";
   const u_int8_t kModuleGUID[sizeof(MDGUID)] = {
     0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
     0x88, 0x99, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF
   };
-  char module_identifier_buffer[37];
+  char module_identifier_buffer[kGUIDStringSize];
   FileID::ConvertIdentifierToString(kModuleGUID,
                                     module_identifier_buffer,
                                     sizeof(module_identifier_buffer));
@@ -187,28 +257,27 @@ TEST(MinidumpWriterTest, MappingInfoContained) {
   // And append a zero, because module IDs include an "age" field
   // which is always zero on Linux.
   module_identifier += "0";
-  
+
   // mmap a file
-  char tempfile[] = TEMPDIR "/minidump-writer-unittest-temp-XXXXXX";
-  mktemp(tempfile);
-  printf("tempfile: %s\n", tempfile);
-  int fd = open(tempfile, O_RDWR | O_CREAT, 0);
+  AutoTempDir temp_dir;
+  string tempfile = temp_dir.path() + "/minidump-writer-unittest-temp";
+  int fd = open(tempfile.c_str(), O_RDWR | O_CREAT, 0);
   ASSERT_NE(-1, fd);
-  unlink(tempfile);
+  unlink(tempfile.c_str());
   // fill with zeros
-  char buffer[kMemorySize];
-  memset(buffer, 0, kMemorySize);
-  ASSERT_EQ(kMemorySize, write(fd, buffer, kMemorySize));
+  google_breakpad::scoped_array<char> buffer(new char[memory_size]);
+  memset(buffer.get(), 0, memory_size);
+  ASSERT_EQ(memory_size, write(fd, buffer.get(), memory_size));
   lseek(fd, 0, SEEK_SET);
 
   char* memory =
     reinterpret_cast<char*>(mmap(NULL,
-                                 kMemorySize,
+                                 memory_size,
                                  PROT_READ | PROT_WRITE,
                                  MAP_PRIVATE,
                                  fd,
                                  0));
-  const u_int64_t kMemoryAddress = reinterpret_cast<u_int64_t>(memory);
+  const uintptr_t kMemoryAddress = reinterpret_cast<uintptr_t>(memory);
   ASSERT_TRUE(memory);
   close(fd);
 
@@ -216,7 +285,7 @@ TEST(MinidumpWriterTest, MappingInfoContained) {
   if (child == 0) {
     close(fds[1]);
     char b;
-    HANDLE_EINTR(read(fds[0], &b, sizeof(b)));
+    IGNORE_RET(HANDLE_EINTR(read(fds[0], &b, sizeof(b))));
     close(fds[0]);
     syscall(__NR_exit);
   }
@@ -224,29 +293,31 @@ TEST(MinidumpWriterTest, MappingInfoContained) {
 
   ExceptionHandler::CrashContext context;
   memset(&context, 0, sizeof(context));
+  context.tid = 1;
 
-  char dumpfile[] = TEMPDIR "/minidump-writer-unittest-XXXXXX";
-  mktemp(dumpfile);
+  string dumpfile = temp_dir.path() + "/minidump-writer-unittest";
 
   // Add information about the mapped memory. Report it as being larger than
   // it actually is.
   MappingInfo info;
-  info.start_addr = kMemoryAddress - kMemorySize;
-  info.size = kMemorySize * 3;
+  info.start_addr = kMemoryAddress - memory_size;
+  info.size = memory_size * 3;
   info.offset = 0;
   strcpy(info.name, kMemoryName);
 
   MappingList mappings;
-  std::pair<MappingInfo, u_int8_t[sizeof(MDGUID)]> mapping;
+  AppMemoryList memory_list;
+  MappingEntry mapping;
   mapping.first = info;
   memcpy(mapping.second, kModuleGUID, sizeof(MDGUID));
   mappings.push_back(mapping);
-  ASSERT_TRUE(WriteMinidump(dumpfile, child, &context, sizeof(context), mappings));
+  ASSERT_TRUE(WriteMinidump(dumpfile.c_str(), child, &context, sizeof(context),
+                            mappings, memory_list));
 
   // Read the minidump. Load the module list, and ensure that
   // the mmap'ed |memory| is listed with the given module name
   // and debug ID.
-  Minidump minidump(dumpfile);
+  Minidump minidump(dumpfile.c_str());
   ASSERT_TRUE(minidump.Read());
 
   MinidumpModuleList* module_list = minidump.GetModuleList();
@@ -260,6 +331,173 @@ TEST(MinidumpWriterTest, MappingInfoContained) {
   EXPECT_EQ(kMemoryName, module->code_file());
   EXPECT_EQ(module_identifier, module->debug_identifier());
 
-  unlink(dumpfile);
+  close(fds[1]);
+}
+
+TEST(MinidumpWriterTest, DeletedBinary) {
+  static const int kNumberOfThreadsInHelperProgram = 1;
+  char kNumberOfThreadsArgument[2];
+  sprintf(kNumberOfThreadsArgument, "%d", kNumberOfThreadsInHelperProgram);
+
+  string helper_path(GetHelperBinary());
+  if (helper_path.empty()) {
+    FAIL() << "Couldn't find helper binary";
+    exit(1);
+  }
+
+  // Copy binary to a temp file.
+  AutoTempDir temp_dir;
+  string binpath = temp_dir.path() + "/linux-dumper-unittest-helper";
+  ASSERT_TRUE(CopyFile(helper_path.c_str(), binpath.c_str()))
+      << "Failed to copy " << helper_path << " to " << binpath;
+  ASSERT_EQ(0, chmod(binpath.c_str(), 0755));
+
+  int fds[2];
+  ASSERT_NE(-1, pipe(fds));
+
+  pid_t child_pid = fork();
+  if (child_pid == 0) {
+    // In child process.
+    close(fds[0]);
+
+    // Pass the pipe fd and the number of threads as arguments.
+    char pipe_fd_string[8];
+    sprintf(pipe_fd_string, "%d", fds[1]);
+    execl(binpath.c_str(),
+          binpath.c_str(),
+          pipe_fd_string,
+          kNumberOfThreadsArgument,
+          NULL);
+  }
+  close(fds[1]);
+  // Wait for the child process to signal that it's ready.
+  struct pollfd pfd;
+  memset(&pfd, 0, sizeof(pfd));
+  pfd.fd = fds[0];
+  pfd.events = POLLIN | POLLERR;
+
+  const int r = HANDLE_EINTR(poll(&pfd, 1, 1000));
+  ASSERT_EQ(1, r);
+  ASSERT_TRUE(pfd.revents & POLLIN);
+  uint8_t junk;
+  const int nr = HANDLE_EINTR(read(fds[0], &junk, sizeof(junk)));
+  ASSERT_EQ(sizeof(junk), nr);
+  close(fds[0]);
+
+  // Child is ready now.
+  // Unlink the test binary.
+  unlink(binpath.c_str());
+
+  ExceptionHandler::CrashContext context;
+  memset(&context, 0, sizeof(context));
+
+  string templ = temp_dir.path() + "/minidump-writer-unittest";
+  // Set a non-zero tid to avoid tripping asserts.
+  context.tid = 1;
+  ASSERT_TRUE(WriteMinidump(templ.c_str(), child_pid, &context,
+                            sizeof(context)));
+  kill(child_pid, SIGKILL);
+
+  struct stat st;
+  ASSERT_EQ(stat(templ.c_str(), &st), 0);
+  ASSERT_GT(st.st_size, 0u);
+
+  Minidump minidump(templ.c_str());
+  ASSERT_TRUE(minidump.Read());
+
+  // Check that the main module filename is correct.
+  MinidumpModuleList* module_list = minidump.GetModuleList();
+  ASSERT_TRUE(module_list);
+  const MinidumpModule* module = module_list->GetMainModule();
+  EXPECT_STREQ(binpath.c_str(), module->code_file().c_str());
+  // Check that the file ID is correct.
+  FileID fileid(helper_path.c_str());
+  uint8_t identifier[sizeof(MDGUID)];
+  EXPECT_TRUE(fileid.ElfFileIdentifier(identifier));
+  char identifier_string[kGUIDStringSize];
+  FileID::ConvertIdentifierToString(identifier,
+                                    identifier_string,
+                                    kGUIDStringSize);
+  string module_identifier(identifier_string);
+  // Strip out dashes
+  size_t pos;
+  while ((pos = module_identifier.find('-')) != string::npos) {
+    module_identifier.erase(pos, 1);
+  }
+  // And append a zero, because module IDs include an "age" field
+  // which is always zero on Linux.
+  module_identifier += "0";
+  EXPECT_EQ(module_identifier, module->debug_identifier());
+}
+
+// Test that an additional memory region can be added to the minidump.
+TEST(MinidumpWriterTest, AdditionalMemory) {
+  int fds[2];
+  ASSERT_NE(-1, pipe(fds));
+
+  // These are defined here so the parent can use them to check the
+  // data from the minidump afterwards.
+  const u_int32_t kMemorySize = sysconf(_SC_PAGESIZE);
+
+  // Get some heap memory.
+  u_int8_t* memory = new u_int8_t[kMemorySize];
+  const uintptr_t kMemoryAddress = reinterpret_cast<uintptr_t>(memory);
+  ASSERT_TRUE(memory);
+
+  // Stick some data into the memory so the contents can be verified.
+  for (u_int32_t i = 0; i < kMemorySize; ++i) {
+    memory[i] = i % 255;
+  }
+
+  const pid_t child = fork();
+  if (child == 0) {
+    close(fds[1]);
+    char b;
+    HANDLE_EINTR(read(fds[0], &b, sizeof(b)));
+    close(fds[0]);
+    syscall(__NR_exit);
+  }
+  close(fds[0]);
+
+  ExceptionHandler::CrashContext context;
+
+  // This needs a valid context for minidump writing to work, but getting
+  // a useful one from the child is too much work, so just use one from
+  // the parent since the child is just a forked copy anyway.
+  ASSERT_EQ(0, getcontext(&context.context));
+  context.tid = child;
+
+  AutoTempDir temp_dir;
+  string templ = temp_dir.path() + "/minidump-writer-unittest";
+  unlink(templ.c_str());
+
+  MappingList mappings;
+  AppMemoryList memory_list;
+
+  // Add the memory region to the list of memory to be included.
+  AppMemory app_memory;
+  app_memory.ptr = memory;
+  app_memory.length = kMemorySize;
+  memory_list.push_back(app_memory);
+  ASSERT_TRUE(WriteMinidump(templ.c_str(), child, &context, sizeof(context),
+                            mappings, memory_list));
+
+  // Read the minidump. Ensure that the memory region is present
+  Minidump minidump(templ.c_str());
+  ASSERT_TRUE(minidump.Read());
+
+  MinidumpMemoryList* dump_memory_list = minidump.GetMemoryList();
+  ASSERT_TRUE(dump_memory_list);
+  const MinidumpMemoryRegion* region =
+    dump_memory_list->GetMemoryRegionForAddress(kMemoryAddress);
+  ASSERT_TRUE(region);
+
+  EXPECT_EQ(kMemoryAddress, region->GetBase());
+  EXPECT_EQ(kMemorySize, region->GetSize());
+
+  // Verify memory contents.
+  EXPECT_EQ(0, memcmp(region->GetMemory(), memory, kMemorySize));
+
+  delete[] memory;
   close(fds[1]);
 }

toolkit/crashreporter/google-breakpad/src/client/linux/minidump_writer/minidump_writer_unittest_utils.cc

@@ -0,0 +1,66 @@
+// Copyright (c) 2011 Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// minidump_writer_unittest_utils.cc:
+// Shared routines used by unittests under client/linux/minidump_writer.
+
+#include <limits.h>
+#include <stdlib.h>
+
+#include "client/linux/minidump_writer/minidump_writer_unittest_utils.h"
+#include "common/linux/safe_readlink.h"
+#include "common/using_std_string.h"
+
+namespace google_breakpad {
+
+string GetHelperBinary() {
+  string helper_path;
+  char *bindir = getenv("bindir");
+  if (bindir) {
+    helper_path = string(bindir) + "/";
+  } else {
+    // Locate helper binary next to the current binary.
+    char self_path[PATH_MAX];
+    if (!SafeReadLink("/proc/self/exe", self_path)) {
+      return "";
+    }
+    helper_path = string(self_path);
+    size_t pos = helper_path.rfind('/');
+    if (pos == string::npos) {
+      return "";
+    }
+    helper_path.erase(pos + 1);
+  }
+
+  helper_path += "linux_dumper_unittest_helper";
+
+  return helper_path;
+}
+
+}  // namespace google_breakpad

toolkit/crashreporter/google-breakpad/src/client/linux/minidump_writer/minidump_writer_unittest_utils.h

@@ -0,0 +1,49 @@
+// Copyright (c) 2012, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// minidump_writer_unittest_utils.h:
+// Shared routines used by unittests under client/linux/minidump_writer.
+
+#ifndef CLIENT_LINUX_MINIDUMP_WRITER_MINIDUMP_WRITER_UNITTEST_UTILS_H_
+#define CLIENT_LINUX_MINIDUMP_WRITER_MINIDUMP_WRITER_UNITTEST_UTILS_H_
+
+#include <string>
+
+#include "common/using_std_string.h"
+
+namespace google_breakpad {
+
+// Returns the full path to linux_dumper_unittest_helper.  The full path is
+// discovered either by using the environment variable "bindir" or by using
+// the location of the main module of the currently running process.
+string GetHelperBinary();
+
+}  // namespace google_breakpad
+
+#endif  // CLIENT_LINUX_MINIDUMP_WRITER_MINIDUMP_WRITER_UNITTEST_UTILS_H_

toolkit/crashreporter/google-breakpad/src/client/linux/sender/google_crash_report_sender.cc

@@ -32,9 +32,9 @@
 #include <string>
 #include <iostream>
 
-using std::string;
+#include "common/using_std_string.h"
 
-DEFINE_string(crash_server, "http://clients2.google.com/cr",
+DEFINE_string(crash_server, "https://clients2.google.com/cr",
               "The crash server to upload minidumps to.");
 DEFINE_string(product_name, "",
               "The product name that the minidump corresponds to.");
@@ -59,7 +59,7 @@ DEFINE_string(proxy_userpasswd, "",
 
 
 bool CheckForRequiredFlagsOrDie() {
-  std::string error_text = "";
+  string error_text = "";
   if (FLAGS_product_name.empty()) {
     error_text.append("\nProduct name must be specified.");
   }

toolkit/crashreporter/google-breakpad/src/client/mac/Breakpad.xcodeproj/project.pbxproj

@@ -35,9 +35,29 @@
 /* End PBXAggregateTarget section */
 
 /* Begin PBXBuildFile section */
+		163201D61443019E00C4DBF5 /* ConfigFile.h in Headers */ = {isa = PBXBuildFile; fileRef = 163201D41443019E00C4DBF5 /* ConfigFile.h */; };
+		163201D71443019E00C4DBF5 /* ConfigFile.mm in Sources */ = {isa = PBXBuildFile; fileRef = 163201D51443019E00C4DBF5 /* ConfigFile.mm */; };
+		163201E31443029300C4DBF5 /* ConfigFile.mm in Sources */ = {isa = PBXBuildFile; fileRef = 163201D51443019E00C4DBF5 /* ConfigFile.mm */; };
+		16C7C918147D45AE00776EAD /* BreakpadDefines.h in Headers */ = {isa = PBXBuildFile; fileRef = 16C7C917147D45AE00776EAD /* BreakpadDefines.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		16E02DB8147410F0008C604D /* uploader.mm in Sources */ = {isa = PBXBuildFile; fileRef = 16E02DB4147410D4008C604D /* uploader.mm */; };
 		3329D4ED0FA16D820007BBC5 /* Breakpad.xib in Resources */ = {isa = PBXBuildFile; fileRef = 3329D4EC0FA16D820007BBC5 /* Breakpad.xib */; };
 		33880C800F9E097100817F82 /* InfoPlist.strings in Resources */ = {isa = PBXBuildFile; fileRef = 33880C7E0F9E097100817F82 /* InfoPlist.strings */; };
 		4084699D0F5D9CF900FDCA37 /* crash_report_sender.icns in Resources */ = {isa = PBXBuildFile; fileRef = 4084699C0F5D9CF900FDCA37 /* crash_report_sender.icns */; };
+		4D61A25F14F43CFC002D5862 /* bootstrap_compat.cc in Sources */ = {isa = PBXBuildFile; fileRef = 4D61A25D14F43CFC002D5862 /* bootstrap_compat.cc */; };
+		4D61A26B14F43D3C002D5862 /* bootstrap_compat.cc in Sources */ = {isa = PBXBuildFile; fileRef = 4D61A25D14F43CFC002D5862 /* bootstrap_compat.cc */; };
+		4D61A26C14F43D42002D5862 /* bootstrap_compat.cc in Sources */ = {isa = PBXBuildFile; fileRef = 4D61A25D14F43CFC002D5862 /* bootstrap_compat.cc */; };
+		4D61A26D14F43D43002D5862 /* bootstrap_compat.cc in Sources */ = {isa = PBXBuildFile; fileRef = 4D61A25D14F43CFC002D5862 /* bootstrap_compat.cc */; };
+		4D61A26E14F43D45002D5862 /* bootstrap_compat.cc in Sources */ = {isa = PBXBuildFile; fileRef = 4D61A25D14F43CFC002D5862 /* bootstrap_compat.cc */; };
+		4D61A26F14F43D48002D5862 /* bootstrap_compat.cc in Sources */ = {isa = PBXBuildFile; fileRef = 4D61A25D14F43CFC002D5862 /* bootstrap_compat.cc */; };
+		4D72CA0E13DFAD5C006CABE3 /* md5.cc in Sources */ = {isa = PBXBuildFile; fileRef = 4D72CA0D13DFAD5C006CABE3 /* md5.cc */; };
+		4D72CA2513DFAE1C006CABE3 /* md5.cc in Sources */ = {isa = PBXBuildFile; fileRef = 4D72CA0D13DFAD5C006CABE3 /* md5.cc */; };
+		4D72CA2F13DFAE65006CABE3 /* md5.cc in Sources */ = {isa = PBXBuildFile; fileRef = 4D72CA0D13DFAD5C006CABE3 /* md5.cc */; };
+		4D72CA3813DFAE91006CABE3 /* md5.cc in Sources */ = {isa = PBXBuildFile; fileRef = 4D72CA0D13DFAD5C006CABE3 /* md5.cc */; };
+		4D72CA3913DFAE92006CABE3 /* md5.cc in Sources */ = {isa = PBXBuildFile; fileRef = 4D72CA0D13DFAD5C006CABE3 /* md5.cc */; };
+		4DBE49A6134A4F200072546A /* CoreServices.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 4DBE4769134A4F080072546A /* CoreServices.framework */; };
+		4DBE49A7134A4F280072546A /* CoreServices.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 4DBE4769134A4F080072546A /* CoreServices.framework */; };
+		4DBE49A8134A4F380072546A /* CoreServices.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 4DBE4769134A4F080072546A /* CoreServices.framework */; };
+		4DBE49A9134A4F460072546A /* CoreServices.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 4DBE4769134A4F080072546A /* CoreServices.framework */; };
 		8B3101C611F0CD9F00FCF3E4 /* AppKit.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 0867D6A5FE840307C02AAC07 /* AppKit.framework */; };
 		8B3101C711F0CD9F00FCF3E4 /* Foundation.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 0867D69BFE84028FC02AAC07 /* Foundation.framework */; };
 		8B3101CA11F0CDB000FCF3E4 /* AppKit.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 0867D6A5FE840307C02AAC07 /* AppKit.framework */; };
@@ -47,9 +67,6 @@
 		8B3102E611F0D74C00FCF3E4 /* Foundation.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 0867D69BFE84028FC02AAC07 /* Foundation.framework */; };
 		8B3102EB11F0D78000FCF3E4 /* Foundation.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 0867D69BFE84028FC02AAC07 /* Foundation.framework */; };
 		8B31FC8211EFD2B800FCF3E4 /* Foundation.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 0867D69BFE84028FC02AAC07 /* Foundation.framework */; };
-		8B4BDAAF12012BC5009C7060 /* libcrypto.dylib in Frameworks */ = {isa = PBXBuildFile; fileRef = 8B4BDAA7120124EA009C7060 /* libcrypto.dylib */; };
-		8B4BDABE12012CEF009C7060 /* libcrypto.dylib in Frameworks */ = {isa = PBXBuildFile; fileRef = 8B4BDAA7120124EA009C7060 /* libcrypto.dylib */; };
-		8B4BDAC512012D05009C7060 /* libcrypto.dylib in Frameworks */ = {isa = PBXBuildFile; fileRef = 8B4BDAA7120124EA009C7060 /* libcrypto.dylib */; };
 		8DC2EF570486A6940098B216 /* Cocoa.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 1058C7B1FEA5585E11CA2CBB /* Cocoa.framework */; };
 		D23F4B2E12A7E13200686C8D /* minidump_generator_test.cc in Sources */ = {isa = PBXBuildFile; fileRef = D23F4B2C12A7E13200686C8D /* minidump_generator_test.cc */; };
 		D23F4B3312A7E17700686C8D /* libgtest.a in Frameworks */ = {isa = PBXBuildFile; fileRef = D2F9A41512131EF0002747C1 /* libgtest.a */; };
@@ -72,7 +89,6 @@
 		D246419112BAA52F005170D0 /* convert_UTF.c in Sources */ = {isa = PBXBuildFile; fileRef = F92C53870ECCE6C0009BE4BA /* convert_UTF.c */; };
 		D246419512BAA54C005170D0 /* file_id.cc in Sources */ = {isa = PBXBuildFile; fileRef = F92C53740ECCE635009BE4BA /* file_id.cc */; };
 		D246419612BAA55A005170D0 /* macho_id.cc in Sources */ = {isa = PBXBuildFile; fileRef = F92C537A0ECCE635009BE4BA /* macho_id.cc */; };
-		D246419C12BAA65F005170D0 /* libcrypto.dylib in Frameworks */ = {isa = PBXBuildFile; fileRef = 8B4BDAA7120124EA009C7060 /* libcrypto.dylib */; };
 		D24641A012BAA67F005170D0 /* macho_walker.cc in Sources */ = {isa = PBXBuildFile; fileRef = F92C537E0ECCE635009BE4BA /* macho_walker.cc */; };
 		D24641AF12BAA82D005170D0 /* macho_utilities.cc in Sources */ = {isa = PBXBuildFile; fileRef = F92C537C0ECCE635009BE4BA /* macho_utilities.cc */; };
 		D24641EC12BAC6FB005170D0 /* logging.cc in Sources */ = {isa = PBXBuildFile; fileRef = D244535112426EBB009BBCE0 /* logging.cc */; };
@@ -119,7 +135,6 @@
 		D2F9A53B121383A1002747C1 /* macho_walker.cc in Sources */ = {isa = PBXBuildFile; fileRef = F92C537E0ECCE635009BE4BA /* macho_walker.cc */; };
 		D2F9A53C121383A1002747C1 /* string_utilities.cc in Sources */ = {isa = PBXBuildFile; fileRef = F92C53820ECCE635009BE4BA /* string_utilities.cc */; };
 		D2F9A53F121383A1002747C1 /* Foundation.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 0867D69BFE84028FC02AAC07 /* Foundation.framework */; };
-		D2F9A540121383A1002747C1 /* libcrypto.dylib in Frameworks */ = {isa = PBXBuildFile; fileRef = 8B4BDAA7120124EA009C7060 /* libcrypto.dylib */; };
 		D2F9A541121383A1002747C1 /* libgtest.a in Frameworks */ = {isa = PBXBuildFile; fileRef = D2F9A41512131EF0002747C1 /* libgtest.a */; };
 		D2F9A553121383DC002747C1 /* crash_generation_server_test.cc in Sources */ = {isa = PBXBuildFile; fileRef = D2F9A4CE121336F7002747C1 /* crash_generation_server_test.cc */; };
 		F91AF5D00FD60393009D8BE2 /* BreakpadFramework_Test.mm in Sources */ = {isa = PBXBuildFile; fileRef = F91AF5CF0FD60393009D8BE2 /* BreakpadFramework_Test.mm */; };
@@ -540,17 +555,25 @@
 		0867D69BFE84028FC02AAC07 /* Foundation.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = Foundation.framework; path = System/Library/Frameworks/Foundation.framework; sourceTree = SDKROOT; };
 		0867D6A5FE840307C02AAC07 /* AppKit.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = AppKit.framework; path = System/Library/Frameworks/AppKit.framework; sourceTree = SDKROOT; };
 		1058C7B1FEA5585E11CA2CBB /* Cocoa.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = Cocoa.framework; path = System/Library/Frameworks/Cocoa.framework; sourceTree = SDKROOT; };
+		163201D41443019E00C4DBF5 /* ConfigFile.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = ConfigFile.h; path = crash_generation/ConfigFile.h; sourceTree = "<group>"; };
+		163201D51443019E00C4DBF5 /* ConfigFile.mm */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.objcpp; fileEncoding = 4; name = ConfigFile.mm; path = crash_generation/ConfigFile.mm; sourceTree = "<group>"; };
+		163202431443201300C4DBF5 /* uploader.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = uploader.h; path = sender/uploader.h; sourceTree = "<group>"; };
+		16C7C917147D45AE00776EAD /* BreakpadDefines.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = BreakpadDefines.h; sourceTree = "<group>"; };
+		16E02DB4147410D4008C604D /* uploader.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; name = uploader.mm; path = sender/uploader.mm; sourceTree = "<group>"; };
 		32DBCF5E0370ADEE00C91783 /* Breakpad_Prefix.pch */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = Breakpad_Prefix.pch; path = Framework/Breakpad_Prefix.pch; sourceTree = "<group>"; };
 		3329D4EC0FA16D820007BBC5 /* Breakpad.xib */ = {isa = PBXFileReference; lastKnownFileType = file.xib; name = Breakpad.xib; path = sender/Breakpad.xib; sourceTree = "<group>"; };
 		33880C7F0F9E097100817F82 /* English */ = {isa = PBXFileReference; fileEncoding = 10; lastKnownFileType = text.plist.strings; name = English; path = sender/English.lproj/InfoPlist.strings; sourceTree = "<group>"; };
 		4084699C0F5D9CF900FDCA37 /* crash_report_sender.icns */ = {isa = PBXFileReference; lastKnownFileType = image.icns; name = crash_report_sender.icns; path = sender/crash_report_sender.icns; sourceTree = "<group>"; };
+		4D61A25D14F43CFC002D5862 /* bootstrap_compat.cc */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = bootstrap_compat.cc; path = ../../common/mac/bootstrap_compat.cc; sourceTree = SOURCE_ROOT; };
+		4D61A25E14F43CFC002D5862 /* bootstrap_compat.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = bootstrap_compat.h; path = ../../common/mac/bootstrap_compat.h; sourceTree = SOURCE_ROOT; };
+		4D72CA0D13DFAD5C006CABE3 /* md5.cc */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = md5.cc; path = ../../common/md5.cc; sourceTree = SOURCE_ROOT; };
+		4DBE4769134A4F080072546A /* CoreServices.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = CoreServices.framework; path = System/Library/Frameworks/CoreServices.framework; sourceTree = SDKROOT; };
 		8B31007011F0CD3C00FCF3E4 /* GTMDefines.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = GTMDefines.h; path = ../../common/mac/GTMDefines.h; sourceTree = SOURCE_ROOT; };
 		8B3101E911F0CDE300FCF3E4 /* SenTestingKit.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = SenTestingKit.framework; path = Library/Frameworks/SenTestingKit.framework; sourceTree = DEVELOPER_DIR; };
 		8B31022211F0CE1000FCF3E4 /* GTMGarbageCollection.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = GTMGarbageCollection.h; path = ../../common/mac/GTMGarbageCollection.h; sourceTree = SOURCE_ROOT; };
 		8B31027711F0D3AF00FCF3E4 /* BreakpadDebug.xcconfig */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xcconfig; name = BreakpadDebug.xcconfig; path = ../../common/mac/BreakpadDebug.xcconfig; sourceTree = SOURCE_ROOT; };
 		8B31027811F0D3AF00FCF3E4 /* BreakpadRelease.xcconfig */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xcconfig; name = BreakpadRelease.xcconfig; path = ../../common/mac/BreakpadRelease.xcconfig; sourceTree = SOURCE_ROOT; };
 		8B31FFF611F0C90500FCF3E4 /* Breakpad.xcconfig */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xcconfig; name = Breakpad.xcconfig; path = ../../common/mac/Breakpad.xcconfig; sourceTree = SOURCE_ROOT; };
-		8B4BDAA7120124EA009C7060 /* libcrypto.dylib */ = {isa = PBXFileReference; lastKnownFileType = "compiled.mach-o.dylib"; name = libcrypto.dylib; path = usr/lib/libcrypto.dylib; sourceTree = SDKROOT; };
 		8DC2EF5B0486A6940098B216 /* Breakpad.framework */ = {isa = PBXFileReference; explicitFileType = wrapper.framework; includeInIndex = 0; path = Breakpad.framework; sourceTree = BUILT_PRODUCTS_DIR; };
 		D23F4B2C12A7E13200686C8D /* minidump_generator_test.cc */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = minidump_generator_test.cc; path = tests/minidump_generator_test.cc; sourceTree = "<group>"; };
 		D23F4B9A12A8688800686C8D /* minidump_generator_test_helper.cc */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = minidump_generator_test_helper.cc; path = tests/minidump_generator_test_helper.cc; sourceTree = "<group>"; };
@@ -572,28 +595,28 @@
 		D2F9A4C8121336C7002747C1 /* crash_generation_server.cc */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = crash_generation_server.cc; path = crash_generation/crash_generation_server.cc; sourceTree = "<group>"; };
 		D2F9A4CE121336F7002747C1 /* crash_generation_server_test.cc */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = crash_generation_server_test.cc; path = tests/crash_generation_server_test.cc; sourceTree = "<group>"; };
 		D2F9A546121383A1002747C1 /* crash_generation_server_test */ = {isa = PBXFileReference; explicitFileType = "compiled.mach-o.executable"; includeInIndex = 0; path = crash_generation_server_test; sourceTree = BUILT_PRODUCTS_DIR; };
-		DE43467411C72855004F095F /* da */ = {isa = PBXFileReference; lastKnownFileType = text.plist.strings; name = da; path = sender/da.lproj/Localizable.strings; sourceTree = "<group>"; };
-		DE43467511C72857004F095F /* de */ = {isa = PBXFileReference; lastKnownFileType = text.plist.strings; name = de; path = sender/de.lproj/Localizable.strings; sourceTree = "<group>"; };
-		DE43467611C7285B004F095F /* es */ = {isa = PBXFileReference; lastKnownFileType = text.plist.strings; name = es; path = sender/es.lproj/Localizable.strings; sourceTree = "<group>"; };
-		DE43467711C72862004F095F /* fr */ = {isa = PBXFileReference; lastKnownFileType = text.plist.strings; name = fr; path = sender/fr.lproj/Localizable.strings; sourceTree = "<group>"; };
-		DE43467811C72869004F095F /* it */ = {isa = PBXFileReference; lastKnownFileType = text.plist.strings; name = it; path = sender/it.lproj/Localizable.strings; sourceTree = "<group>"; };
-		DE43467911C7286D004F095F /* nl */ = {isa = PBXFileReference; lastKnownFileType = text.plist.strings; name = nl; path = sender/nl.lproj/Localizable.strings; sourceTree = "<group>"; };
-		DE43467A11C72873004F095F /* no */ = {isa = PBXFileReference; lastKnownFileType = text.plist.strings; name = no; path = sender/no.lproj/Localizable.strings; sourceTree = "<group>"; };
-		DE43467B11C72877004F095F /* sl */ = {isa = PBXFileReference; lastKnownFileType = text.plist.strings; name = sl; path = sender/sl.lproj/Localizable.strings; sourceTree = "<group>"; };
-		DE43467C11C7287A004F095F /* sv */ = {isa = PBXFileReference; lastKnownFileType = text.plist.strings; name = sv; path = sender/sv.lproj/Localizable.strings; sourceTree = "<group>"; };
-		DE43467E11C728DC004F095F /* ja */ = {isa = PBXFileReference; lastKnownFileType = text.plist.strings; name = ja; path = sender/ja.lproj/Localizable.strings; sourceTree = "<group>"; };
-		DE43467F11C728E1004F095F /* tr */ = {isa = PBXFileReference; lastKnownFileType = text.plist.strings; name = tr; path = sender/tr.lproj/Localizable.strings; sourceTree = "<group>"; };
-		DE43468611C72958004F095F /* de */ = {isa = PBXFileReference; lastKnownFileType = text.plist.strings; name = de; path = sender/de.lproj/InfoPlist.strings; sourceTree = "<group>"; };
-		DE43468711C7295D004F095F /* da */ = {isa = PBXFileReference; lastKnownFileType = text.plist.strings; name = da; path = sender/da.lproj/InfoPlist.strings; sourceTree = "<group>"; };
-		DE43468811C7295F004F095F /* es */ = {isa = PBXFileReference; lastKnownFileType = text.plist.strings; name = es; path = sender/es.lproj/InfoPlist.strings; sourceTree = "<group>"; };
-		DE43468911C72964004F095F /* fr */ = {isa = PBXFileReference; lastKnownFileType = text.plist.strings; name = fr; path = sender/fr.lproj/InfoPlist.strings; sourceTree = "<group>"; };
-		DE43468A11C72967004F095F /* it */ = {isa = PBXFileReference; lastKnownFileType = text.plist.strings; name = it; path = sender/it.lproj/InfoPlist.strings; sourceTree = "<group>"; };
-		DE43468B11C7296B004F095F /* ja */ = {isa = PBXFileReference; lastKnownFileType = text.plist.strings; name = ja; path = sender/ja.lproj/InfoPlist.strings; sourceTree = "<group>"; };
-		DE43468C11C7296D004F095F /* nl */ = {isa = PBXFileReference; lastKnownFileType = text.plist.strings; name = nl; path = sender/nl.lproj/InfoPlist.strings; sourceTree = "<group>"; };
-		DE43468D11C7296F004F095F /* no */ = {isa = PBXFileReference; lastKnownFileType = text.plist.strings; name = no; path = sender/no.lproj/InfoPlist.strings; sourceTree = "<group>"; };
-		DE43468E11C72971004F095F /* sl */ = {isa = PBXFileReference; lastKnownFileType = text.plist.strings; name = sl; path = sender/sl.lproj/InfoPlist.strings; sourceTree = "<group>"; };
-		DE43468F11C72973004F095F /* sv */ = {isa = PBXFileReference; lastKnownFileType = text.plist.strings; name = sv; path = sender/sv.lproj/InfoPlist.strings; sourceTree = "<group>"; };
-		DE43469011C72976004F095F /* tr */ = {isa = PBXFileReference; lastKnownFileType = text.plist.strings; name = tr; path = sender/tr.lproj/InfoPlist.strings; sourceTree = "<group>"; };
+		DE43467411C72855004F095F /* da */ = {isa = PBXFileReference; fileEncoding = 10; lastKnownFileType = text.plist.strings; name = da; path = sender/da.lproj/Localizable.strings; sourceTree = "<group>"; };
+		DE43467511C72857004F095F /* de */ = {isa = PBXFileReference; fileEncoding = 10; lastKnownFileType = text.plist.strings; name = de; path = sender/de.lproj/Localizable.strings; sourceTree = "<group>"; };
+		DE43467611C7285B004F095F /* es */ = {isa = PBXFileReference; fileEncoding = 10; lastKnownFileType = text.plist.strings; name = es; path = sender/es.lproj/Localizable.strings; sourceTree = "<group>"; };
+		DE43467711C72862004F095F /* fr */ = {isa = PBXFileReference; fileEncoding = 10; lastKnownFileType = text.plist.strings; name = fr; path = sender/fr.lproj/Localizable.strings; sourceTree = "<group>"; };
+		DE43467811C72869004F095F /* it */ = {isa = PBXFileReference; fileEncoding = 10; lastKnownFileType = text.plist.strings; name = it; path = sender/it.lproj/Localizable.strings; sourceTree = "<group>"; };
+		DE43467911C7286D004F095F /* nl */ = {isa = PBXFileReference; fileEncoding = 10; lastKnownFileType = text.plist.strings; name = nl; path = sender/nl.lproj/Localizable.strings; sourceTree = "<group>"; };
+		DE43467A11C72873004F095F /* no */ = {isa = PBXFileReference; fileEncoding = 10; lastKnownFileType = text.plist.strings; name = no; path = sender/no.lproj/Localizable.strings; sourceTree = "<group>"; };
+		DE43467B11C72877004F095F /* sl */ = {isa = PBXFileReference; fileEncoding = 10; lastKnownFileType = text.plist.strings; name = sl; path = sender/sl.lproj/Localizable.strings; sourceTree = "<group>"; };
+		DE43467C11C7287A004F095F /* sv */ = {isa = PBXFileReference; fileEncoding = 10; lastKnownFileType = text.plist.strings; name = sv; path = sender/sv.lproj/Localizable.strings; sourceTree = "<group>"; };
+		DE43467E11C728DC004F095F /* ja */ = {isa = PBXFileReference; fileEncoding = 10; lastKnownFileType = text.plist.strings; name = ja; path = sender/ja.lproj/Localizable.strings; sourceTree = "<group>"; };
+		DE43467F11C728E1004F095F /* tr */ = {isa = PBXFileReference; fileEncoding = 10; lastKnownFileType = text.plist.strings; name = tr; path = sender/tr.lproj/Localizable.strings; sourceTree = "<group>"; };
+		DE43468611C72958004F095F /* de */ = {isa = PBXFileReference; fileEncoding = 10; lastKnownFileType = text.plist.strings; name = de; path = sender/de.lproj/InfoPlist.strings; sourceTree = "<group>"; };
+		DE43468711C7295D004F095F /* da */ = {isa = PBXFileReference; fileEncoding = 10; lastKnownFileType = text.plist.strings; name = da; path = sender/da.lproj/InfoPlist.strings; sourceTree = "<group>"; };
+		DE43468811C7295F004F095F /* es */ = {isa = PBXFileReference; fileEncoding = 10; lastKnownFileType = text.plist.strings; name = es; path = sender/es.lproj/InfoPlist.strings; sourceTree = "<group>"; };
+		DE43468911C72964004F095F /* fr */ = {isa = PBXFileReference; fileEncoding = 10; lastKnownFileType = text.plist.strings; name = fr; path = sender/fr.lproj/InfoPlist.strings; sourceTree = "<group>"; };
+		DE43468A11C72967004F095F /* it */ = {isa = PBXFileReference; fileEncoding = 10; lastKnownFileType = text.plist.strings; name = it; path = sender/it.lproj/InfoPlist.strings; sourceTree = "<group>"; };
+		DE43468B11C7296B004F095F /* ja */ = {isa = PBXFileReference; fileEncoding = 10; lastKnownFileType = text.plist.strings; name = ja; path = sender/ja.lproj/InfoPlist.strings; sourceTree = "<group>"; };
+		DE43468C11C7296D004F095F /* nl */ = {isa = PBXFileReference; fileEncoding = 10; lastKnownFileType = text.plist.strings; name = nl; path = sender/nl.lproj/InfoPlist.strings; sourceTree = "<group>"; };
+		DE43468D11C7296F004F095F /* no */ = {isa = PBXFileReference; fileEncoding = 10; lastKnownFileType = text.plist.strings; name = no; path = sender/no.lproj/InfoPlist.strings; sourceTree = "<group>"; };
+		DE43468E11C72971004F095F /* sl */ = {isa = PBXFileReference; fileEncoding = 10; lastKnownFileType = text.plist.strings; name = sl; path = sender/sl.lproj/InfoPlist.strings; sourceTree = "<group>"; };
+		DE43468F11C72973004F095F /* sv */ = {isa = PBXFileReference; fileEncoding = 10; lastKnownFileType = text.plist.strings; name = sv; path = sender/sv.lproj/InfoPlist.strings; sourceTree = "<group>"; };
+		DE43469011C72976004F095F /* tr */ = {isa = PBXFileReference; fileEncoding = 10; lastKnownFileType = text.plist.strings; name = tr; path = sender/tr.lproj/InfoPlist.strings; sourceTree = "<group>"; };
 		F91AF5CF0FD60393009D8BE2 /* BreakpadFramework_Test.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; name = BreakpadFramework_Test.mm; path = tests/BreakpadFramework_Test.mm; sourceTree = "<group>"; };
 		F9286B380F7EB25800A4DCC8 /* Inspector.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = Inspector.h; path = crash_generation/Inspector.h; sourceTree = "<group>"; };
 		F9286B390F7EB25800A4DCC8 /* InspectorMain.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; name = InspectorMain.mm; path = crash_generation/InspectorMain.mm; sourceTree = "<group>"; };
@@ -661,7 +684,7 @@
 		F9C44DAF0EF07288003AEBAA /* Info.plist */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.plist.xml; name = Info.plist; path = testapp/Info.plist; sourceTree = "<group>"; };
 		F9C44DB00EF07288003AEBAA /* main.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; name = main.m; path = testapp/main.m; sourceTree = "<group>"; };
 		F9C44DB10EF07288003AEBAA /* TestClass.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; name = TestClass.mm; path = testapp/TestClass.mm; sourceTree = "<group>"; };
-		F9C44DB90EF072A0003AEBAA /* English */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.plist.strings; name = English; path = testapp/English.lproj/InfoPlist.strings; sourceTree = "<group>"; };
+		F9C44DB90EF072A0003AEBAA /* English */ = {isa = PBXFileReference; fileEncoding = 10; lastKnownFileType = text.plist.strings; name = English; path = testapp/English.lproj/InfoPlist.strings; sourceTree = "<group>"; };
 		F9C44DBB0EF072A0003AEBAA /* English */ = {isa = PBXFileReference; lastKnownFileType = file.xib; name = English; path = testapp/English.lproj/MainMenu.xib; sourceTree = "<group>"; };
 		F9C44DBF0EF0778F003AEBAA /* Controller.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = Controller.h; path = testapp/Controller.h; sourceTree = "<group>"; };
 		F9C44DC00EF0778F003AEBAA /* TestClass.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = TestClass.h; path = testapp/TestClass.h; sourceTree = "<group>"; };
@@ -691,7 +714,7 @@
 			buildActionMask = 2147483647;
 			files = (
 				D246418412BAA4BA005170D0 /* Foundation.framework in Frameworks */,
-				D246419C12BAA65F005170D0 /* libcrypto.dylib in Frameworks */,
+				4DBE49A6134A4F200072546A /* CoreServices.framework in Frameworks */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;
 		};
@@ -707,8 +730,8 @@
 			buildActionMask = 2147483647;
 			files = (
 				D2F9A53F121383A1002747C1 /* Foundation.framework in Frameworks */,
-				D2F9A540121383A1002747C1 /* libcrypto.dylib in Frameworks */,
 				D2F9A541121383A1002747C1 /* libgtest.a in Frameworks */,
+				4DBE49A9134A4F460072546A /* CoreServices.framework in Frameworks */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;
 		};
@@ -727,7 +750,6 @@
 			files = (
 				8B31FC8211EFD2B800FCF3E4 /* Foundation.framework in Frameworks */,
 				F92C56570ECD113E009BE4BA /* Carbon.framework in Frameworks */,
-				8B4BDAAF12012BC5009C7060 /* libcrypto.dylib in Frameworks */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;
 		};
@@ -746,8 +768,8 @@
 			buildActionMask = 2147483647;
 			files = (
 				8B31029411F0D54300FCF3E4 /* Foundation.framework in Frameworks */,
-				8B4BDABE12012CEF009C7060 /* libcrypto.dylib in Frameworks */,
 				D23F4B3312A7E17700686C8D /* libgtest.a in Frameworks */,
+				4DBE49A7134A4F280072546A /* CoreServices.framework in Frameworks */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;
 		};
@@ -763,8 +785,8 @@
 			buildActionMask = 2147483647;
 			files = (
 				8B3102E611F0D74C00FCF3E4 /* Foundation.framework in Frameworks */,
-				8B4BDAC512012D05009C7060 /* libcrypto.dylib in Frameworks */,
 				D2F9A44412131F84002747C1 /* libgtest.a in Frameworks */,
+				4DBE49A8134A4F380072546A /* CoreServices.framework in Frameworks */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;
 		};
@@ -833,17 +855,34 @@
 		0867D69AFE84028FC02AAC07 /* Frameworks */ = {
 			isa = PBXGroup;
 			children = (
-				8B4BDAA7120124EA009C7060 /* libcrypto.dylib */,
 				8B3101E911F0CDE300FCF3E4 /* SenTestingKit.framework */,
 				F9C44EE40EF0A006003AEBAA /* SystemConfiguration.framework */,
 				F92C554A0ECCF530009BE4BA /* Carbon.framework */,
 				1058C7B1FEA5585E11CA2CBB /* Cocoa.framework */,
 				0867D6A5FE840307C02AAC07 /* AppKit.framework */,
 				0867D69BFE84028FC02AAC07 /* Foundation.framework */,
+				4DBE4769134A4F080072546A /* CoreServices.framework */,
 			);
 			name = Frameworks;
 			sourceTree = "<group>";
 		};
+		16C7C915147D45AE00776EAD /* apple */ = {
+			isa = PBXGroup;
+			children = (
+				16C7C916147D45AE00776EAD /* Framework */,
+			);
+			name = apple;
+			path = ../apple;
+			sourceTree = SOURCE_ROOT;
+		};
+		16C7C916147D45AE00776EAD /* Framework */ = {
+			isa = PBXGroup;
+			children = (
+				16C7C917147D45AE00776EAD /* BreakpadDefines.h */,
+			);
+			path = Framework;
+			sourceTree = "<group>";
+		};
 		D244536912426EE7009BBCE0 /* processor */ = {
 			isa = PBXGroup;
 			children = (
@@ -890,6 +929,7 @@
 				D244540A12439BA0009BBCE0 /* memory_unittest.cc */,
 				F92C53870ECCE6C0009BE4BA /* convert_UTF.c */,
 				F92C53880ECCE6C0009BE4BA /* convert_UTF.h */,
+				4D72CA0D13DFAD5C006CABE3 /* md5.cc */,
 				F92C53850ECCE6AD009BE4BA /* string_conversion.cc */,
 				F92C53860ECCE6AD009BE4BA /* string_conversion.h */,
 				F92C53840ECCE68D009BE4BA /* mac */,
@@ -911,6 +951,8 @@
 				F92C53770ECCE635009BE4BA /* HTTPMultipartUpload.m */,
 				F92C53780ECCE635009BE4BA /* MachIPC.h */,
 				F92C53790ECCE635009BE4BA /* MachIPC.mm */,
+				4D61A25D14F43CFC002D5862 /* bootstrap_compat.cc */,
+				4D61A25E14F43CFC002D5862 /* bootstrap_compat.h */,
 				F92C537A0ECCE635009BE4BA /* macho_id.cc */,
 				F92C537B0ECCE635009BE4BA /* macho_id.h */,
 				F92C537C0ECCE635009BE4BA /* macho_utilities.cc */,
@@ -928,6 +970,7 @@
 		F92C538D0ECCE6F2009BE4BA /* client */ = {
 			isa = PBXGroup;
 			children = (
+				16C7C915147D45AE00776EAD /* apple */,
 				F92C53990ECCE78E009BE4BA /* mac */,
 				F92C538E0ECCE70A009BE4BA /* minidump_file_writer-inl.h */,
 				F92C538F0ECCE70A009BE4BA /* minidump_file_writer.cc */,
@@ -953,6 +996,8 @@
 		F92C53B50ECCE799009BE4BA /* crash_generation */ = {
 			isa = PBXGroup;
 			children = (
+				163201D41443019E00C4DBF5 /* ConfigFile.h */,
+				163201D51443019E00C4DBF5 /* ConfigFile.mm */,
 				D2F9A4C4121336C7002747C1 /* client_info.h */,
 				D2F9A4C5121336C7002747C1 /* crash_generation_client.h */,
 				D2F9A4C6121336C7002747C1 /* crash_generation_client.cc */,
@@ -980,6 +1025,8 @@
 		F92C56A60ECE04B6009BE4BA /* sender */ = {
 			isa = PBXGroup;
 			children = (
+				16E02DB4147410D4008C604D /* uploader.mm */,
+				163202431443201300C4DBF5 /* uploader.h */,
 				F9B6309F100FF96B00D0F4AC /* goArrow.png */,
 				F92C56A70ECE04C5009BE4BA /* crash_report_sender.h */,
 				F92C56A80ECE04C5009BE4BA /* crash_report_sender.m */,
@@ -1093,6 +1140,8 @@
 				D2F9A4C9121336C7002747C1 /* client_info.h in Headers */,
 				D2F9A4CA121336C7002747C1 /* crash_generation_client.h in Headers */,
 				D2F9A4CC121336C7002747C1 /* crash_generation_server.h in Headers */,
+				163201D61443019E00C4DBF5 /* ConfigFile.h in Headers */,
+				16C7C918147D45AE00776EAD /* BreakpadDefines.h in Headers */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;
 		};
@@ -1337,6 +1386,7 @@
 			isa = PBXProject;
 			buildConfigurationList = 1DEB91B108733DA50010E9CD /* Build configuration list for PBXProject "Breakpad" */;
 			compatibilityVersion = "Xcode 3.1";
+			developmentRegion = English;
 			hasScannedForEncodings = 1;
 			knownRegions = (
 				English,
@@ -1615,6 +1665,7 @@
 				F92C56340ECD0DF1009BE4BA /* OnDemandServer.mm in Sources */,
 				D2F9A4CB121336C7002747C1 /* crash_generation_client.cc in Sources */,
 				D2F9A4CD121336C7002747C1 /* crash_generation_server.cc in Sources */,
+				163201D71443019E00C4DBF5 /* ConfigFile.mm in Sources */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;
 		};
@@ -1637,6 +1688,8 @@
 				D246419612BAA55A005170D0 /* macho_id.cc in Sources */,
 				D24641A012BAA67F005170D0 /* macho_walker.cc in Sources */,
 				D24641AF12BAA82D005170D0 /* macho_utilities.cc in Sources */,
+				4D72CA2513DFAE1C006CABE3 /* md5.cc in Sources */,
+				4D61A26C14F43D42002D5862 /* bootstrap_compat.cc in Sources */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;
 		};
@@ -1674,6 +1727,8 @@
 				D24641ED12BAC6FB005170D0 /* minidump.cc in Sources */,
 				D24641EE12BAC6FB005170D0 /* pathname_stripper.cc in Sources */,
 				D24641EF12BAC6FB005170D0 /* basic_code_modules.cc in Sources */,
+				4D72CA3913DFAE92006CABE3 /* md5.cc in Sources */,
+				4D61A26F14F43D48002D5862 /* bootstrap_compat.cc in Sources */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;
 		};
@@ -1683,6 +1738,8 @@
 			files = (
 				F92C53B80ECCE7B3009BE4BA /* Inspector.mm in Sources */,
 				F9286B3A0F7EB25800A4DCC8 /* InspectorMain.mm in Sources */,
+				163201E31443029300C4DBF5 /* ConfigFile.mm in Sources */,
+				4D61A26B14F43D3C002D5862 /* bootstrap_compat.cc in Sources */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;
 		};
@@ -1698,11 +1755,13 @@
 				F92C56430ECD10CA009BE4BA /* macho_utilities.cc in Sources */,
 				F92C56440ECD10CA009BE4BA /* macho_walker.cc in Sources */,
 				F92C56450ECD10CA009BE4BA /* MachIPC.mm in Sources */,
+				4D72CA0E13DFAD5C006CABE3 /* md5.cc in Sources */,
 				F92C56460ECD10CA009BE4BA /* minidump_file_writer.cc in Sources */,
 				F92C56470ECD10CA009BE4BA /* minidump_generator.cc in Sources */,
 				F92C56480ECD10CA009BE4BA /* SimpleStringDictionary.mm in Sources */,
 				F92C56490ECD10CA009BE4BA /* string_utilities.cc in Sources */,
 				F92C564A0ECD10CA009BE4BA /* string_conversion.cc in Sources */,
+				4D61A25F14F43CFC002D5862 /* bootstrap_compat.cc in Sources */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;
 		};
@@ -1713,6 +1772,7 @@
 				F9C44EA20EF09F93003AEBAA /* HTTPMultipartUpload.m in Sources */,
 				F92C56A90ECE04C5009BE4BA /* crash_report_sender.m in Sources */,
 				F9C44EE90EF0A3C1003AEBAA /* GTMLogger.m in Sources */,
+				16E02DB8147410F0008C604D /* uploader.mm in Sources */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;
 		};
@@ -1740,6 +1800,8 @@
 				F93803D60F8083B7004D428B /* macho_walker.cc in Sources */,
 				F93803D70F8083B7004D428B /* string_utilities.cc in Sources */,
 				D23F4B2E12A7E13200686C8D /* minidump_generator_test.cc in Sources */,
+				4D72CA2F13DFAE65006CABE3 /* md5.cc in Sources */,
+				4D61A26D14F43D43002D5862 /* bootstrap_compat.cc in Sources */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;
 		};
@@ -1779,6 +1841,8 @@
 				F93DE33F0F82C66B00608B94 /* string_utilities.cc in Sources */,
 				D2F9A3D51212F87C002747C1 /* exception_handler_test.cc in Sources */,
 				D244540B12439BA0009BBCE0 /* memory_unittest.cc in Sources */,
+				4D72CA3813DFAE91006CABE3 /* md5.cc in Sources */,
+				4D61A26E14F43D45002D5862 /* bootstrap_compat.cc in Sources */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;
 		};
@@ -2044,9 +2108,6 @@
 			buildSettings = {
 				GCC_TREAT_WARNINGS_AS_ERRORS = NO;
 				SDKROOT = macosx10.5;
-				"SDKROOT[arch=i386]" = macosx10.4;
-				"SDKROOT[arch=ppc]" = macosx10.4;
-				"SDKROOT[arch=x86_64]" = macosx10.6;
 			};
 			name = Debug;
 		};
@@ -2080,6 +2141,7 @@
 				ALWAYS_SEARCH_USER_PATHS = NO;
 				GCC_ENABLE_FIX_AND_CONTINUE = YES;
 				GCC_MODEL_TUNING = G5;
+				HEADER_SEARCH_PATHS = ../..;
 				INSTALL_PATH = /usr/local/bin;
 				PREBINDING = NO;
 				PRODUCT_NAME = minidump_generator_test_helper;
@@ -2094,6 +2156,7 @@
 				DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym";
 				GCC_ENABLE_FIX_AND_CONTINUE = NO;
 				GCC_MODEL_TUNING = G5;
+				HEADER_SEARCH_PATHS = ../..;
 				INSTALL_PATH = /usr/local/bin;
 				PREBINDING = NO;
 				PRODUCT_NAME = minidump_generator_test_helper;
@@ -2109,7 +2172,7 @@
 				GCC_DYNAMIC_NO_PIC = NO;
 				GCC_OPTIMIZATION_LEVEL = 0;
 				HEADER_SEARCH_PATHS = (
-					$inherited,
+					"$(inherited)",
 					../../testing,
 					../../testing/include,
 					../../testing/gtest,
@@ -2124,6 +2187,13 @@
 			isa = XCBuildConfiguration;
 			buildSettings = {
 				ALWAYS_SEARCH_USER_PATHS = NO;
+				HEADER_SEARCH_PATHS = (
+					"$(inherited)",
+					../../testing,
+					../../testing/include,
+					../../testing/gtest,
+					../../testing/gtest/include,
+				);
 				PREBINDING = NO;
 				PRODUCT_NAME = gtest;
 			};
@@ -2136,6 +2206,13 @@
 				COPY_PHASE_STRIP = YES;
 				DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym";
 				GCC_ENABLE_FIX_AND_CONTINUE = NO;
+				HEADER_SEARCH_PATHS = (
+					"$(inherited)",
+					../../testing,
+					../../testing/include,
+					../../testing/gtest,
+					../../testing/gtest/include,
+				);
 				PREBINDING = NO;
 				PRODUCT_NAME = gtest;
 				ZERO_LINK = NO;
@@ -2167,24 +2244,36 @@
 		D2F9A544121383A1002747C1 /* Debug With Code Coverage */ = {
 			isa = XCBuildConfiguration;
 			buildSettings = {
-				HEADER_SEARCH_PATHS = ../..;
+				HEADER_SEARCH_PATHS = (
+					../..,
+					../../testing,
+					../../testing/include,
+					../../testing/gtest,
+					../../testing/gtest/include,
+				);
 				LIBRARY_SEARCH_PATHS = (
 					"$(inherited)",
 					"\\\"$(SRCROOT)/build/Debug\\\"",
 				);
-				PRODUCT_NAME = handler_test;
+				PRODUCT_NAME = crash_generation_server_test;
 			};
 			name = "Debug With Code Coverage";
 		};
 		D2F9A545121383A1002747C1 /* Release */ = {
 			isa = XCBuildConfiguration;
 			buildSettings = {
-				HEADER_SEARCH_PATHS = ../..;
+				HEADER_SEARCH_PATHS = (
+					../..,
+					../../testing,
+					../../testing/include,
+					../../testing/gtest,
+					../../testing/gtest/include,
+				);
 				LIBRARY_SEARCH_PATHS = (
 					"$(inherited)",
 					"\\\"$(SRCROOT)/build/Debug\\\"",
 				);
-				PRODUCT_NAME = handler_test;
+				PRODUCT_NAME = crash_generation_server_test;
 			};
 			name = Release;
 		};
@@ -2271,7 +2360,14 @@
 		F93803C10F808210004D428B /* Release */ = {
 			isa = XCBuildConfiguration;
 			buildSettings = {
-				HEADER_SEARCH_PATHS = ../..;
+				HEADER_SEARCH_PATHS = (
+					../..,
+					../../..,
+					../../testing,
+					../../testing/include,
+					../../testing/gtest,
+					../../testing/gtest/include,
+				);
 				PRODUCT_NAME = generator_test;
 			};
 			name = Release;
@@ -2318,7 +2414,14 @@
 		F93DE32F0F82C55700608B94 /* Release */ = {
 			isa = XCBuildConfiguration;
 			buildSettings = {
-				HEADER_SEARCH_PATHS = ../..;
+				HEADER_SEARCH_PATHS = (
+					../../..,
+					../..,
+					../../testing,
+					../../testing/include,
+					../../testing/gtest,
+					../../testing/gtest/include,
+				);
 				LIBRARY_SEARCH_PATHS = (
 					"$(inherited)",
 					"\"$(SRCROOT)/build/Debug\"",
@@ -2417,7 +2520,14 @@
 		F93DE3C10F830E7000608B94 /* Debug With Code Coverage */ = {
 			isa = XCBuildConfiguration;
 			buildSettings = {
-				HEADER_SEARCH_PATHS = ../..;
+				HEADER_SEARCH_PATHS = (
+					../..,
+					../../..,
+					../../testing,
+					../../testing/include,
+					../../testing/gtest,
+					../../testing/gtest/include,
+				);
 				PRODUCT_NAME = generator_test;
 			};
 			name = "Debug With Code Coverage";
@@ -2433,7 +2543,14 @@
 		F93DE3C30F830E7000608B94 /* Debug With Code Coverage */ = {
 			isa = XCBuildConfiguration;
 			buildSettings = {
-				HEADER_SEARCH_PATHS = ../..;
+				HEADER_SEARCH_PATHS = (
+					../../..,
+					../..,
+					../../testing,
+					../../testing/include,
+					../../testing/gtest,
+					../../testing/gtest/include,
+				);
 				LIBRARY_SEARCH_PATHS = (
 					"$(inherited)",
 					"\"$(SRCROOT)/build/Debug\"",

toolkit/crashreporter/google-breakpad/src/client/mac/Framework/Breakpad.h

@@ -41,6 +41,10 @@
 // modify the default behavior to suit your needs and wants and
 // desires.
 
+// A service name associated with the original bootstrap parent port, saved in
+// OnDemandServer and restored in Inspector.
+#define BREAKPAD_BOOTSTRAP_PARENT_PORT    "com.Breakpad.BootstrapParent"
+
 typedef void *BreakpadRef;
 
 #ifdef __cplusplus
@@ -50,46 +54,7 @@ extern "C" {
 #include <CoreFoundation/CoreFoundation.h>
 #include <Foundation/Foundation.h>
 
-  // Keys for configuration file
-#define kReporterMinidumpDirectoryKey "MinidumpDir"
-#define kReporterMinidumpIDKey        "MinidumpID"
-
-// The default subdirectory of the Library to put crash dumps in
-// The subdirectory is
-//  ~/Library/<kDefaultLibrarySubdirectory>/<GoogleBreakpadProduct>
-#define kDefaultLibrarySubdirectory   "Breakpad"
-
-// Specify some special keys to be used in the configuration file that is
-// generated by Breakpad and consumed by the crash_sender.
-#define BREAKPAD_PRODUCT               "BreakpadProduct"
-#define BREAKPAD_PRODUCT_DISPLAY       "BreakpadProductDisplay"
-#define BREAKPAD_VERSION               "BreakpadVersion"
-#define BREAKPAD_VENDOR                "BreakpadVendor"
-#define BREAKPAD_URL                   "BreakpadURL"
-#define BREAKPAD_REPORT_INTERVAL       "BreakpadReportInterval"
-#define BREAKPAD_SKIP_CONFIRM          "BreakpadSkipConfirm"
-#define BREAKPAD_CONFIRM_TIMEOUT       "BreakpadConfirmTimeout"
-#define BREAKPAD_SEND_AND_EXIT         "BreakpadSendAndExit"
-#define BREAKPAD_DUMP_DIRECTORY        "BreakpadMinidumpLocation"
-#define BREAKPAD_INSPECTOR_LOCATION    "BreakpadInspectorLocation"
-#define BREAKPAD_REPORTER_EXE_LOCATION \
-  "BreakpadReporterExeLocation"
-#define BREAKPAD_LOGFILES              "BreakpadLogFiles"
-#define BREAKPAD_LOGFILE_UPLOAD_SIZE   "BreakpadLogFileTailSize"
-#define BREAKPAD_REQUEST_COMMENTS      "BreakpadRequestComments"
-#define BREAKPAD_COMMENTS              "BreakpadComments"
-#define BREAKPAD_REQUEST_EMAIL         "BreakpadRequestEmail"
-#define BREAKPAD_EMAIL                 "BreakpadEmail"
-#define BREAKPAD_SERVER_TYPE           "BreakpadServerType"
-#define BREAKPAD_SERVER_PARAMETER_DICT "BreakpadServerParameters"
-
-// The keys below are NOT user supplied, and are used internally.
-#define BREAKPAD_PROCESS_START_TIME       "BreakpadProcStartTime"
-#define BREAKPAD_PROCESS_UP_TIME          "BreakpadProcessUpTime"
-#define BREAKPAD_PROCESS_CRASH_TIME       "BreakpadProcessCrashTime"
-#define BREAKPAD_LOGFILE_KEY_PREFIX       "BreakpadAppLogFile"
-#define BREAKPAD_SERVER_PARAMETER_PREFIX  "BreakpadServerParameterPrefix_"
-#define BREAKPAD_ON_DEMAND                "BreakpadOnDemand"
+#include "BreakpadDefines.h"
 
 // Optional user-defined function to dec to decide if we should handle
 // this crash or forward it along.
@@ -221,13 +186,15 @@ typedef bool (*BreakpadFilterCallback)(int exception_type,
 // completeness.  They are calculated by Breakpad during initialization &
 // crash-dump generation, or entered in by the user.
 //
-// BREAKPAD_PROCESS_START_TIME       The time the process started.
+// BREAKPAD_PROCESS_START_TIME       The time, in seconds since the Epoch, the
+//                                   process started
 //
-// BREAKPAD_PROCESS_CRASH_TIME       The time the process crashed.
+// BREAKPAD_PROCESS_CRASH_TIME       The time, in seconds since the Epoch, the
+//                                   process crashed.
 //
-// BREAKPAD_PROCESS_UP_TIME          The total time the process has been
-//                                   running.  This parameter is not set
-//                                   until the crash-dump-generation phase.
+// BREAKPAD_PROCESS_UP_TIME          The total time in milliseconds the process
+//                                   has been running.  This parameter is not
+//                                   set until the crash-dump-generation phase.
 //
 // BREAKPAD_LOGFILE_KEY_PREFIX       Used to find out which parameters in the
 //                                   parameter dictionary correspond to log

toolkit/crashreporter/google-breakpad/src/client/mac/Framework/Breakpad.mm

@@ -39,20 +39,19 @@
 #define DEBUGLOG if (gDebugLog) fprintf
 #define IGNORE_DEBUGGER "BREAKPAD_IGNORE_DEBUGGER"
 
-#import "common/mac/MachIPC.h"
-#import "common/mac/SimpleStringDictionary.h"
+#import "client/mac/Framework/Breakpad.h"
+
+#import <Foundation/Foundation.h>
+#import <sys/stat.h>
+#import <sys/sysctl.h>
 
 #import "client/mac/crash_generation/Inspector.h"
 #import "client/mac/handler/exception_handler.h"
 #import "client/mac/Framework/Breakpad.h"
 #import "client/mac/Framework/OnDemandServer.h"
 #import "client/mac/handler/protected_memory_allocator.h"
-
-#import <sys/stat.h>
-#import <sys/sysctl.h>
-
-#import <Foundation/Foundation.h>
-
+#import "common/mac/MachIPC.h"
+#import "common/mac/SimpleStringDictionary.h"
 
 using google_breakpad::KeyValueEntry;
 using google_breakpad::MachPortSender;

toolkit/crashreporter/google-breakpad/src/client/mac/Framework/OnDemandServer.h

@@ -27,13 +27,12 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-#import <iostream>
-#import <mach/mach.h>
-#import <servers/bootstrap.h>
-#import <stdio.h>
-#import <stdlib.h>
-#import <sys/stat.h>
-#import <unistd.h>
+#include <mach/mach.h>
+#include <servers/bootstrap.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/stat.h>
+#include <unistd.h>
 
 //==============================================================================
 // class OnDemandServer :

toolkit/crashreporter/google-breakpad/src/client/mac/Framework/OnDemandServer.mm

@@ -29,11 +29,23 @@
 
 #import "OnDemandServer.h"
 
+#import "Breakpad.h"
+#include "common/mac/bootstrap_compat.h"
+
 #if DEBUG
   #define PRINT_MACH_RESULT(result_, message_) \
     printf(message_"%s (%d)\n", mach_error_string(result_), result_ );
+#if defined(MAC_OS_X_VERSION_10_5) && \
+    MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5
+  #define PRINT_BOOTSTRAP_RESULT(result_, message_) \
+    printf(message_"%s (%d)\n", bootstrap_strerror(result_), result_ );
+#else
+  #define PRINT_BOOTSTRAP_RESULT(result_, message_) \
+    PRINT_MACH_RESULT(result_, message_)
+#endif
 #else
   #define PRINT_MACH_RESULT(result_, message_)
+  #define PRINT_BOOTSTRAP_RESULT(result_, message_)
 #endif
 
 //==============================================================================
@@ -67,34 +79,66 @@ kern_return_t OnDemandServer::Initialize(const char *server_command,
                                          bool unregister_on_cleanup) {
   unregister_on_cleanup_ = unregister_on_cleanup;
 
-  kern_return_t kr =
-    bootstrap_create_server(bootstrap_port,
-                            const_cast<char*>(server_command),
-                            geteuid(),       // server uid
-                            true,
-                            &server_port_);
+  mach_port_t self_task = mach_task_self();
 
+  mach_port_t bootstrap_port;
+  kern_return_t kr = task_get_bootstrap_port(self_task, &bootstrap_port);
   if (kr != KERN_SUCCESS) {
-    PRINT_MACH_RESULT(kr, "bootstrap_create_server() : ");
+    PRINT_MACH_RESULT(kr, "task_get_bootstrap_port(): ");
+    return kr;
+  }
+
+  mach_port_t bootstrap_subset_port;
+  kr = bootstrap_subset(bootstrap_port, self_task, &bootstrap_subset_port);
+  if (kr != BOOTSTRAP_SUCCESS) {
+    PRINT_BOOTSTRAP_RESULT(kr, "bootstrap_subset(): ");
+    return kr;
+  }
+
+  // The inspector will be invoked with its bootstrap port set to the subset,
+  // but the sender will need access to the original bootstrap port. Although
+  // the original port is the subset's parent, bootstrap_parent can't be used
+  // because it requires extra privileges. Stash the original bootstrap port
+  // in the subset by registering it under a known name. The inspector will
+  // recover this port and set it as its own bootstrap port in Inspector.mm
+  // Inspector::ResetBootstrapPort.
+  kr = breakpad::BootstrapRegister(
+      bootstrap_subset_port,
+      const_cast<char*>(BREAKPAD_BOOTSTRAP_PARENT_PORT),
+      bootstrap_port);
+  if (kr != BOOTSTRAP_SUCCESS) {
+    PRINT_BOOTSTRAP_RESULT(kr, "bootstrap_register(): ");
+    return kr;
+  }
+
+  kr = bootstrap_create_server(bootstrap_subset_port,
+                               const_cast<char*>(server_command),
+                               geteuid(),       // server uid
+                               true,
+                               &server_port_);
+  if (kr != BOOTSTRAP_SUCCESS) {
+    PRINT_BOOTSTRAP_RESULT(kr, "bootstrap_create_server(): ");
     return kr;
   }
 
   strlcpy(service_name_, service_name, sizeof(service_name_));
 
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdeprecated-declarations"
   // Create a service called service_name, and return send rights to
   // that port in service_port_.
   kr = bootstrap_create_service(server_port_,
                                 const_cast<char*>(service_name),
                                 &service_port_);
-
-  if (kr != KERN_SUCCESS) {
-    PRINT_MACH_RESULT(kr, "bootstrap_create_service() : ");
+#pragma clang diagnostic pop
+  if (kr != BOOTSTRAP_SUCCESS) {
+    PRINT_BOOTSTRAP_RESULT(kr, "bootstrap_create_service(): ");
 
     // perhaps the service has already been created - try to look it up
     kr = bootstrap_look_up(bootstrap_port, (char*)service_name, &service_port_);
 
-    if (kr != KERN_SUCCESS) {
-      PRINT_MACH_RESULT(kr, "bootstrap_look_up() : ");
+    if (kr != BOOTSTRAP_SUCCESS) {
+      PRINT_BOOTSTRAP_RESULT(kr, "bootstrap_look_up(): ");
       Unregister();  // clean up server port
       return kr;
     }
@@ -131,9 +175,9 @@ void OnDemandServer::Unregister() {
 
   if (server_port_ != MACH_PORT_NULL) {
     // unregister the service
-    kern_return_t kr = bootstrap_register(server_port_,
-                                          service_name_,
-                                          MACH_PORT_NULL);
+    kern_return_t kr = breakpad::BootstrapRegister(server_port_,
+                                                   service_name_,
+                                                   MACH_PORT_NULL);
 
     if (kr != KERN_SUCCESS) {
       PRINT_MACH_RESULT(kr, "Breakpad UNREGISTER : bootstrap_register() : ");

toolkit/crashreporter/google-breakpad/src/client/mac/crash_generation/ConfigFile.h

@@ -0,0 +1,83 @@
+// Copyright (c) 2011, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// Utility class that can persist a SimpleStringDictionary to disk.
+
+#import <Foundation/Foundation.h>
+
+#import "common/mac/SimpleStringDictionary.h"
+
+namespace google_breakpad {
+
+BOOL EnsureDirectoryPathExists(NSString *dirPath);
+
+//=============================================================================
+class ConfigFile {
+ public:
+  ConfigFile() {
+    config_file_ = -1;
+    config_file_path_[0] = 0;
+    has_created_file_ = false;
+  };
+
+  ~ConfigFile() {
+  };
+
+  void WriteFile(const char* directory,
+                 const SimpleStringDictionary *configurationParameters,
+                 const char *dump_dir,
+                 const char *minidump_id);
+
+  const char *GetFilePath() { return config_file_path_; }
+
+  void Unlink() {
+    if (config_file_ != -1)
+      unlink(config_file_path_);
+
+    config_file_ = -1;
+  }
+
+ private:
+  BOOL WriteData(const void *data, size_t length);
+
+  BOOL AppendConfigData(const char *key,
+                        const void *data,
+                        size_t length);
+
+  BOOL AppendConfigString(const char *key,
+                          const char *value);
+
+  BOOL AppendCrashTimeParameters(const char *processStartTimeString);
+
+  int   config_file_;                    // descriptor for config file
+  char  config_file_path_[PATH_MAX];     // Path to configuration file
+  bool  has_created_file_;
+};
+
+} // namespace google_breakpad

toolkit/crashreporter/google-breakpad/src/client/mac/crash_generation/ConfigFile.mm

@@ -0,0 +1,190 @@
+// Copyright (c) 2011, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// Utility class that can persist a SimpleStringDictionary to disk.
+
+#import "client/mac/crash_generation/ConfigFile.h"
+
+#import <Foundation/Foundation.h>
+#include <stdio.h>
+#include <sys/time.h>
+
+#import "client/apple/Framework/BreakpadDefines.h"
+#import "common/mac/SimpleStringDictionary.h"
+#import "GTMDefines.h"
+
+#define VERBOSE 0
+
+#if VERBOSE
+  bool gDebugLog = true;
+#else
+  bool gDebugLog = false;
+#endif
+
+#define DEBUGLOG if (gDebugLog) fprintf
+
+namespace google_breakpad {
+
+//=============================================================================
+BOOL EnsureDirectoryPathExists(NSString *dirPath) {
+  NSFileManager *mgr = [NSFileManager defaultManager];
+
+  NSDictionary *attrs =
+    [NSDictionary dictionaryWithObject:[NSNumber numberWithUnsignedLong:0750]
+                                forKey:NSFilePosixPermissions];
+
+  return [mgr createDirectoryAtPath:dirPath
+        withIntermediateDirectories:YES
+                         attributes:attrs
+                              error:nil];
+}
+
+//=============================================================================
+BOOL ConfigFile::WriteData(const void *data, size_t length) {
+  size_t result = write(config_file_, data, length);
+
+  return result == length;
+}
+
+//=============================================================================
+BOOL ConfigFile::AppendConfigData(const char *key,
+                                  const void *data, size_t length) {
+  assert(config_file_ != -1);
+
+  if (!key) {
+    DEBUGLOG(stderr, "Breakpad: Missing Key\n");
+    return NO;
+  }
+
+  if (!data) {
+    DEBUGLOG(stderr, "Breakpad: Missing data for key: %s\n", key ? key :
+            "<Unknown Key>");
+    return NO;
+  }
+
+  // Write the key, \n, length of data (ascii integer), \n, data
+  char buffer[16];
+  char nl = '\n';
+  BOOL result = WriteData(key, strlen(key));
+
+  snprintf(buffer, sizeof(buffer) - 1, "\n%lu\n", length);
+  result &= WriteData(buffer, strlen(buffer));
+  result &= WriteData(data, length);
+  result &= WriteData(&nl, 1);
+  return result;
+}
+
+//=============================================================================
+BOOL ConfigFile::AppendConfigString(const char *key,
+                                    const char *value) {
+  return AppendConfigData(key, value, strlen(value));
+}
+
+//=============================================================================
+BOOL ConfigFile::AppendCrashTimeParameters(const char *processStartTimeString) {
+  // Set process uptime parameter
+  struct timeval tv;
+  gettimeofday(&tv, NULL);
+
+  char processUptimeString[32], processCrashtimeString[32];
+  // Set up time if we've received the start time.
+  if (processStartTimeString) {
+    time_t processStartTime = strtol(processStartTimeString, NULL, 10);
+    time_t processUptime = tv.tv_sec - processStartTime;
+    // Store the uptime in milliseconds.
+    sprintf(processUptimeString, "%llu",
+        static_cast<unsigned long long int>(processUptime) * 1000);
+    if (!AppendConfigString(BREAKPAD_PROCESS_UP_TIME, processUptimeString))
+      return false;
+  }
+
+  sprintf(processCrashtimeString, "%zd", tv.tv_sec);
+  return AppendConfigString(BREAKPAD_PROCESS_CRASH_TIME,
+                            processCrashtimeString);
+}
+
+//=============================================================================
+void ConfigFile::WriteFile(const char* directory,
+                           const SimpleStringDictionary *configurationParameters,
+                           const char *dump_dir,
+                           const char *minidump_id) {
+
+  assert(config_file_ == -1);
+
+  // Open and write out configuration file preamble
+  if (directory) {
+    snprintf(config_file_path_, sizeof(config_file_path_), "%s/Config-XXXXXX",
+             directory);
+  } else {
+    strlcpy(config_file_path_, "/tmp/Config-XXXXXX",
+            sizeof(config_file_path_));
+  }
+  config_file_ = mkstemp(config_file_path_);
+
+  if (config_file_ == -1) {
+    DEBUGLOG(stderr,
+             "mkstemp(config_file_path_) == -1 (%s)\n",
+             strerror(errno));
+    return;
+  }
+  else {
+    DEBUGLOG(stderr, "Writing config file to (%s)\n", config_file_path_);
+  }
+
+  has_created_file_ = true;
+
+  // Add the minidump dir
+  AppendConfigString(kReporterMinidumpDirectoryKey, dump_dir);
+  AppendConfigString(kReporterMinidumpIDKey, minidump_id);
+
+  // Write out the configuration parameters
+  BOOL result = YES;
+  const SimpleStringDictionary &dictionary = *configurationParameters;
+
+  const KeyValueEntry *entry = NULL;
+  SimpleStringDictionaryIterator iter(dictionary);
+
+  while ((entry = iter.Next())) {
+    DEBUGLOG(stderr,
+             "config: (%s) -> (%s)\n",
+             entry->GetKey(),
+             entry->GetValue());
+    result = AppendConfigString(entry->GetKey(), entry->GetValue());
+
+    if (!result)
+      break;
+  }
+  AppendCrashTimeParameters(
+      configurationParameters->GetValueForKey(BREAKPAD_PROCESS_START_TIME));
+
+  close(config_file_);
+  config_file_ = -1;
+}
+
+} // namespace google_breakpad

toolkit/crashreporter/google-breakpad/src/client/mac/crash_generation/Inspector.h

@@ -33,9 +33,10 @@
 #import "common/mac/SimpleStringDictionary.h"
 
 #import <Foundation/Foundation.h>
-#import "client/mac/handler/minidump_generator.h"
+#include <mach/mach.h>
 
-#define VERBOSE 0
+#import "client/mac/crash_generation/ConfigFile.h"
+#import "client/mac/handler/minidump_generator.h"
 
 extern bool gDebugLog;
 
@@ -78,52 +79,10 @@ using google_breakpad::MinidumpGenerator;
 
 namespace google_breakpad {
 
-static BOOL EnsureDirectoryPathExists(NSString *dirPath);
-
-//=============================================================================
-class ConfigFile {
- public:
-  ConfigFile() {
-    config_file_ = -1;
-    config_file_path_[0] = 0;
-    has_created_file_ = false;
-  };
-
-  ~ConfigFile() {
-  };
-
-  void WriteFile(const SimpleStringDictionary *configurationParameters,
-                 const char *dump_dir,
-                 const char *minidump_id);
-
-  const char *GetFilePath() { return config_file_path_; }
-
-  void Unlink() {
-    if (config_file_ != -1)
-      unlink(config_file_path_);
-
-    config_file_ = -1;
-  }
-
- private:
-  BOOL WriteData(const void *data, size_t length);
-
-  BOOL AppendConfigData(const char *key,
-                        const void *data,
-                        size_t length);
-
-  BOOL AppendConfigString(const char *key,
-                          const char *value);
-
-  int   config_file_;                    // descriptor for config file
-  char  config_file_path_[PATH_MAX];     // Path to configuration file
-  bool  has_created_file_;
-};
-
 //=============================================================================
 class MinidumpLocation {
  public:
-  MinidumpLocation(const NSString *minidumpDir) {
+  MinidumpLocation(NSString *minidumpDir) {
     // Ensure that the path exists.  Fallback to /tmp if unable to locate path.
     assert(minidumpDir);
     if (!EnsureDirectoryPathExists(minidumpDir)) {
@@ -163,6 +122,18 @@ class Inspector {
   void            Inspect(const char *receive_port_name);
 
  private:
+  // The Inspector is invoked with its bootstrap port set to the bootstrap
+  // subset established in OnDemandServer.mm OnDemandServer::Initialize.
+  // For proper communication with the system, the sender (which will inherit
+  // the Inspector's bootstrap port) needs the per-session bootstrap namespace
+  // available directly in its bootstrap port. OnDemandServer stashed this
+  // port into the subset namespace under a special name. ResetBootstrapPort
+  // recovers this port and switches this task to use it as its own bootstrap
+  // (ensuring that children like the sender will inherit it), and saves the
+  // subset in bootstrap_subset_port_ for use by ServiceCheckIn and
+  // ServiceCheckOut.
+  kern_return_t   ResetBootstrapPort();
+
   kern_return_t   ServiceCheckIn(const char *receive_port_name);
   kern_return_t   ServiceCheckOut(const char *receive_port_name);
 
@@ -172,7 +143,9 @@ class Inspector {
   kern_return_t   SendAcknowledgement();
   void            LaunchReporter(const char *inConfigFilePath);
 
-  void            SetCrashTimeParameters();
+  // The bootstrap port in which the inspector is registered and into which it
+  // must check in.
+  mach_port_t     bootstrap_subset_port_;
 
   mach_port_t     service_rcv_port_;
 

toolkit/crashreporter/google-breakpad/src/client/mac/crash_generation/Inspector.mm

@@ -31,10 +31,10 @@
 
 #include <cstdio>
 #include <iostream>
+#include <servers/bootstrap.h>
 #include <stdio.h>
 #include <string.h>
 #include <string>
-#include <sys/time.h>
 
 #import "client/mac/crash_generation/Inspector.h"
 
@@ -43,167 +43,22 @@
 
 #import "common/mac/SimpleStringDictionary.h"
 #import "common/mac/MachIPC.h"
+#include "common/mac/bootstrap_compat.h"
 
 #import "GTMDefines.h"
 
 #import <Foundation/Foundation.h>
 
-#if VERBOSE
-  bool gDebugLog = true;
-#else
-  bool gDebugLog = false;
-#endif
-
 namespace google_breakpad {
 
 //=============================================================================
-static BOOL EnsureDirectoryPathExists(NSString *dirPath) {
-  NSFileManager *mgr = [NSFileManager defaultManager];
-
-  // If we got a relative path, prepend the current directory
-  if (![dirPath isAbsolutePath])
-    dirPath = [[mgr currentDirectoryPath] stringByAppendingPathComponent:dirPath];
-
-  NSString *path = dirPath;
-
-  // Ensure that no file exists within the path which would block creation
-  while (1) {
-    BOOL isDir;
-    if ([mgr fileExistsAtPath:path isDirectory:&isDir]) {
-      if (isDir)
-        break;
-
-      return NO;
-    }
-
-    path = [path stringByDeletingLastPathComponent];
-  }
-
-  // Path now contains the first valid directory (or is empty)
-  if (![path length])
-    return NO;
-
-  NSString *common =
-    [dirPath commonPrefixWithString:path options:NSLiteralSearch];
-
-  // If everything is good
-  if ([common isEqualToString:dirPath])
-    return YES;
-
-  // Break up the difference into components
-  NSString *diff = [dirPath substringFromIndex:[common length] + 1];
-  NSArray *components = [diff pathComponents];
-  NSUInteger count = [components count];
-
-  // Rebuild the path one component at a time
-  NSDictionary *attrs =
-    [NSDictionary dictionaryWithObject:[NSNumber numberWithUnsignedLong:0750]
-                                forKey:NSFilePosixPermissions];
-  path = common;
-  for (NSUInteger i = 0; i < count; ++i) {
-    path = [path stringByAppendingPathComponent:[components objectAtIndex:i]];
-
-    if (![mgr createDirectoryAtPath:path attributes:attrs])
-      return NO;
-  }
-
-  return YES;
-}
-
-//=============================================================================
-BOOL ConfigFile::WriteData(const void *data, size_t length) {
-  size_t result = write(config_file_, data, length);
-
-  return result == length;
-}
-
-//=============================================================================
-BOOL ConfigFile::AppendConfigData(const char *key,
-                                  const void *data, size_t length) {
-  assert(config_file_ != -1);
-
-  if (!key) {
-    DEBUGLOG(stderr, "Breakpad: Missing Key\n");
-    return NO;
-  }
-
-  if (!data) {
-    DEBUGLOG(stderr, "Breakpad: Missing data for key: %s\n", key ? key :
-            "<Unknown Key>");
-    return NO;
-  }
-
-  // Write the key, \n, length of data (ascii integer), \n, data
-  char buffer[16];
-  char nl = '\n';
-  BOOL result = WriteData(key, strlen(key));
-
-  snprintf(buffer, sizeof(buffer) - 1, "\n%lu\n", length);
-  result &= WriteData(buffer, strlen(buffer));
-  result &= WriteData(data, length);
-  result &= WriteData(&nl, 1);
-  return result;
-}
-
-//=============================================================================
-BOOL ConfigFile::AppendConfigString(const char *key,
-                                    const char *value) {
-  return AppendConfigData(key, value, strlen(value));
-}
-
-//=============================================================================
-void ConfigFile::WriteFile(const SimpleStringDictionary *configurationParameters,
-                           const char *dump_dir,
-                           const char *minidump_id) {
-
-  assert(config_file_ == -1);
-
-  // Open and write out configuration file preamble
-  strlcpy(config_file_path_, "/tmp/Config-XXXXXX",
-          sizeof(config_file_path_));
-  config_file_ = mkstemp(config_file_path_);
-
-  if (config_file_ == -1) {
-    DEBUGLOG(stderr,
-             "mkstemp(config_file_path_) == -1 (%s)\n",
-             strerror(errno));
+void Inspector::Inspect(const char *receive_port_name) {
+  kern_return_t result = ResetBootstrapPort();
+  if (result != KERN_SUCCESS) {
     return;
   }
-  else {
-    DEBUGLOG(stderr, "Writing config file to (%s)\n", config_file_path_);
-  }
 
-  has_created_file_ = true;
-
-  // Add the minidump dir
-  AppendConfigString(kReporterMinidumpDirectoryKey, dump_dir);
-  AppendConfigString(kReporterMinidumpIDKey, minidump_id);
-
-  // Write out the configuration parameters
-  BOOL result = YES;
-  const SimpleStringDictionary &dictionary = *configurationParameters;
-
-  const KeyValueEntry *entry = NULL;
-  SimpleStringDictionaryIterator iter(dictionary);
-
-  while ((entry = iter.Next())) {
-    DEBUGLOG(stderr,
-             "config: (%s) -> (%s)\n",
-             entry->GetKey(),
-             entry->GetValue());
-    result = AppendConfigString(entry->GetKey(), entry->GetValue());
-
-    if (!result)
-      break;
-  }
-
-  close(config_file_);
-  config_file_ = -1;
-}
-
-//=============================================================================
-void Inspector::Inspect(const char *receive_port_name) {
-  kern_return_t result = ServiceCheckIn(receive_port_name);
+  result = ServiceCheckIn(receive_port_name);
 
   if (result == KERN_SUCCESS) {
     result = ReadMessages();
@@ -240,11 +95,56 @@ void Inspector::Inspect(const char *receive_port_name) {
   }
 }
 
+//=============================================================================
+kern_return_t Inspector::ResetBootstrapPort() {
+  // A reasonable default, in case anything fails.
+  bootstrap_subset_port_ = bootstrap_port;
+
+  mach_port_t self_task = mach_task_self();
+
+  kern_return_t kr = task_get_bootstrap_port(self_task,
+                                             &bootstrap_subset_port_);
+  if (kr != KERN_SUCCESS) {
+    NSLog(@"ResetBootstrapPort: task_get_bootstrap_port failed: %s (%d)",
+          mach_error_string(kr), kr);
+    return kr;
+  }
+
+  mach_port_t bootstrap_parent_port;
+  kr = bootstrap_look_up(bootstrap_subset_port_,
+                         const_cast<char*>(BREAKPAD_BOOTSTRAP_PARENT_PORT),
+                         &bootstrap_parent_port);
+  if (kr != BOOTSTRAP_SUCCESS) {
+    NSLog(@"ResetBootstrapPort: bootstrap_look_up failed: %s (%d)",
+#if defined(MAC_OS_X_VERSION_10_5) && \
+    MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5
+          bootstrap_strerror(kr),
+#else
+          mach_error_string(kr),
+#endif
+          kr);
+    return kr;
+  }
+
+  kr = task_set_bootstrap_port(self_task, bootstrap_parent_port);
+  if (kr != KERN_SUCCESS) {
+    NSLog(@"ResetBootstrapPort: task_set_bootstrap_port failed: %s (%d)",
+          mach_error_string(kr), kr);
+    return kr;
+  }
+
+  // Some things access the bootstrap port through this global variable
+  // instead of calling task_get_bootstrap_port.
+  bootstrap_port = bootstrap_parent_port;
+
+  return KERN_SUCCESS;
+}
+
 //=============================================================================
 kern_return_t Inspector::ServiceCheckIn(const char *receive_port_name) {
   // We need to get the mach port representing this service, so we can
   // get information from the crashed process.
-  kern_return_t kr = bootstrap_check_in(bootstrap_port,
+  kern_return_t kr = bootstrap_check_in(bootstrap_subset_port_,
                                         (char*)receive_port_name,
                                         &service_rcv_port_);
 
@@ -275,9 +175,9 @@ kern_return_t Inspector::ServiceCheckOut(const char *receive_port_name) {
   }
 
   // Unregister the service associated with the receive port.
-  kr = bootstrap_register(bootstrap_port,
-                          (char*)receive_port_name,
-                          MACH_PORT_NULL);
+  kr = breakpad::BootstrapRegister(bootstrap_subset_port_,
+                                   (char*)receive_port_name,
+                                   MACH_PORT_NULL);
 
   if (kr != KERN_SUCCESS) {
     PRINT_MACH_RESULT(kr, "Inspector: UNREGISTERING: bootstrap_register()");
@@ -363,30 +263,6 @@ kern_return_t Inspector::ReadMessages() {
 }
 
 //=============================================================================
-// Sets keys in the parameters dictionary that are specific to process uptime.
-// The two we set are process up time, and process crash time.
-void Inspector::SetCrashTimeParameters() {
-  // Set process uptime parameter
-  struct timeval tv;
-  gettimeofday(&tv, NULL);
-
-  char processUptimeString[32], processCrashtimeString[32];
-  const char *processStartTimeString =
-    config_params_.GetValueForKey(BREAKPAD_PROCESS_START_TIME);
-
-  // Set up time if we've received the start time.
-  if (processStartTimeString) {
-    time_t processStartTime = strtol(processStartTimeString, NULL, 10);
-    time_t processUptime = tv.tv_sec - processStartTime;
-    sprintf(processUptimeString, "%zd", processUptime);
-    config_params_.SetKeyValue(BREAKPAD_PROCESS_UP_TIME, processUptimeString);
-  }
-
-  sprintf(processCrashtimeString, "%zd", tv.tv_sec);
-  config_params_.SetKeyValue(BREAKPAD_PROCESS_CRASH_TIME,
-                             processCrashtimeString);
-}
-
 bool Inspector::InspectTask() {
   // keep the task quiet while we're looking at it
   task_suspend(remote_task_);
@@ -397,7 +273,6 @@ bool Inspector::InspectTask() {
   const char *minidumpDirectory =
     config_params_.GetValueForKey(BREAKPAD_DUMP_DIRECTORY);
 
-  SetCrashTimeParameters();
   // If the client app has not specified a minidump directory,
   // use a default of Library/<kDefaultLibrarySubdirectory>/<Product Name>
   if (!minidumpDirectory || 0 == strlen(minidumpDirectory)) {
@@ -448,7 +323,8 @@ bool Inspector::InspectTask() {
            [minidumpPath UTF8String]);
 
 
-  config_file_.WriteFile( &config_params_,
+  config_file_.WriteFile( 0,
+                          &config_params_,
                           minidumpLocation.GetPath(),
                           minidumpLocation.GetID());
 

toolkit/crashreporter/google-breakpad/src/client/mac/crash_generation/crash_generation_server.h

@@ -65,14 +65,14 @@ class CrashGenerationServer {
 
   typedef void (*OnClientExitingCallback)(void *context,
                                           const ClientInfo &client_info);
+  // If a FilterCallback returns false, the dump will not be written.
   typedef bool (*FilterCallback)(void *context);
 
   // Create an instance with the given parameters.
   //
   // mach_port_name: Named server port to listen on.
-  // filter: Callback for a client to know that we are about to write a dump
-  // and mabybe prevent it.
-  // filter_context: Context for the filte callback.
+  // filter: Callback for a client to cancel writing a dump.
+  // filter_context: Context for the filter callback.
   // dump_callback: Callback for a client crash dump request.
   // dump_context: Context for client crash dump request callback.
   // exit_callback: Callback for client process exit.

toolkit/crashreporter/google-breakpad/src/client/mac/handler/Makefile.in

@@ -17,9 +17,9 @@ LOCAL_INCLUDES 	= -I$(srcdir)/../../..
 
 CPPSRCS	= \
   breakpad_nlist_64.cc \
+  dynamic_images.cc \
   exception_handler.cc \
   minidump_generator.cc \
-  dynamic_images.cc \
   $(NULL)
 
 # need static lib

toolkit/crashreporter/google-breakpad/src/client/mac/handler/breakpad_exc_server.h

@@ -1,258 +0,0 @@
-#ifndef	_exc_user_
-#define	_exc_user_
-
-/* Module exc */
-
-#include <string.h>
-#include <mach/ndr.h>
-#include <mach/boolean.h>
-#include <mach/kern_return.h>
-#include <mach/notify.h>
-#include <mach/mach_types.h>
-#include <mach/message.h>
-#include <mach/mig_errors.h>
-#include <mach/port.h>
-
-#ifdef AUTOTEST
-#ifndef FUNCTION_PTR_T
-#define FUNCTION_PTR_T
-typedef void (*function_ptr_t)(mach_port_t, char *, mach_msg_type_number_t);
-typedef struct {
-        char            *name;
-        function_ptr_t  function;
-} function_table_entry;
-typedef function_table_entry 	*function_table_t;
-#endif /* FUNCTION_PTR_T */
-#endif /* AUTOTEST */
-
-#ifndef	exc_MSG_COUNT
-#define	exc_MSG_COUNT	3
-#endif	/* exc_MSG_COUNT */
-
-#include <mach/std_types.h>
-#include <mach/mig.h>
-#include <mach/mig.h>
-#include <mach/mach_types.h>
-
-#ifdef __BeforeMigUserHeader
-__BeforeMigUserHeader
-#endif /* __BeforeMigUserHeader */
-
-#include <sys/cdefs.h>
-__BEGIN_DECLS
-
-
-/* Routine exception_raise */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-kern_return_t exception_raise
-(
-	mach_port_t exception_port,
-	mach_port_t thread,
-	mach_port_t task,
-	exception_type_t exception,
-	exception_data_t code,
-	mach_msg_type_number_t codeCnt
-);
-
-/* Routine exception_raise_state */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-kern_return_t exception_raise_state
-(
-	mach_port_t exception_port,
-	exception_type_t exception,
-	const exception_data_t code,
-	mach_msg_type_number_t codeCnt,
-	int *flavor,
-	const thread_state_t old_state,
-	mach_msg_type_number_t old_stateCnt,
-	thread_state_t new_state,
-	mach_msg_type_number_t *new_stateCnt
-);
-
-/* Routine exception_raise_state_identity */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-kern_return_t exception_raise_state_identity
-(
-	mach_port_t exception_port,
-	mach_port_t thread,
-	mach_port_t task,
-	exception_type_t exception,
-	exception_data_t code,
-	mach_msg_type_number_t codeCnt,
-	int *flavor,
-	thread_state_t old_state,
-	mach_msg_type_number_t old_stateCnt,
-	thread_state_t new_state,
-	mach_msg_type_number_t *new_stateCnt
-);
-
-__END_DECLS
-
-/********************** Caution **************************/
-/* The following data types should be used to calculate  */
-/* maximum message sizes only. The actual message may be */
-/* smaller, and the position of the arguments within the */
-/* message layout may vary from what is presented here.  */
-/* For example, if any of the arguments are variable-    */
-/* sized, and less than the maximum is sent, the data    */
-/* will be packed tight in the actual message to reduce  */
-/* the presence of holes.                                */
-/********************** Caution **************************/
-
-/* typedefs for all requests */
-
-#ifndef __Request__exc_subsystem__defined
-#define __Request__exc_subsystem__defined
-
-#ifdef  __MigPackStructs
-#pragma pack(4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		/* start of the kernel processed data */
-		mach_msg_body_t msgh_body;
-		mach_msg_port_descriptor_t thread;
-		mach_msg_port_descriptor_t task;
-		/* end of the kernel processed data */
-		NDR_record_t NDR;
-		exception_type_t exception;
-		mach_msg_type_number_t codeCnt;
-		integer_t code[2];
-	} __Request__exception_raise_t;
-#ifdef  __MigPackStructs
-#pragma pack()
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		exception_type_t exception;
-		mach_msg_type_number_t codeCnt;
-		integer_t code[2];
-		int flavor;
-		mach_msg_type_number_t old_stateCnt;
-		natural_t old_state[144];
-	} __Request__exception_raise_state_t;
-#ifdef  __MigPackStructs
-#pragma pack()
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		/* start of the kernel processed data */
-		mach_msg_body_t msgh_body;
-		mach_msg_port_descriptor_t thread;
-		mach_msg_port_descriptor_t task;
-		/* end of the kernel processed data */
-		NDR_record_t NDR;
-		exception_type_t exception;
-		mach_msg_type_number_t codeCnt;
-		integer_t code[2];
-		int flavor;
-		mach_msg_type_number_t old_stateCnt;
-		natural_t old_state[144];
-	} __Request__exception_raise_state_identity_t;
-#ifdef  __MigPackStructs
-#pragma pack()
-#endif
-#endif /* !__Request__exc_subsystem__defined */
-
-/* union of all requests */
-
-#ifndef __RequestUnion__exc_subsystem__defined
-#define __RequestUnion__exc_subsystem__defined
-union __RequestUnion__exc_subsystem {
-	__Request__exception_raise_t Request_exception_raise;
-	__Request__exception_raise_state_t Request_exception_raise_state;
-	__Request__exception_raise_state_identity_t Request_exception_raise_state_identity;
-};
-#endif /* !__RequestUnion__exc_subsystem__defined */
-/* typedefs for all replies */
-
-#ifndef __Reply__exc_subsystem__defined
-#define __Reply__exc_subsystem__defined
-
-#ifdef  __MigPackStructs
-#pragma pack(4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		kern_return_t RetCode;
-	} __Reply__exception_raise_t;
-#ifdef  __MigPackStructs
-#pragma pack()
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		kern_return_t RetCode;
-		int flavor;
-		mach_msg_type_number_t new_stateCnt;
-		natural_t new_state[144];
-	} __Reply__exception_raise_state_t;
-#ifdef  __MigPackStructs
-#pragma pack()
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		kern_return_t RetCode;
-		int flavor;
-		mach_msg_type_number_t new_stateCnt;
-		natural_t new_state[144];
-	} __Reply__exception_raise_state_identity_t;
-#ifdef  __MigPackStructs
-#pragma pack()
-#endif
-#endif /* !__Reply__exc_subsystem__defined */
-
-/* union of all replies */
-
-#ifndef __ReplyUnion__exc_subsystem__defined
-#define __ReplyUnion__exc_subsystem__defined
-union __ReplyUnion__exc_subsystem {
-	__Reply__exception_raise_t Reply_exception_raise;
-	__Reply__exception_raise_state_t Reply_exception_raise_state;
-	__Reply__exception_raise_state_identity_t Reply_exception_raise_state_identity;
-};
-#endif /* !__RequestUnion__exc_subsystem__defined */
-
-#ifndef subsystem_to_name_map_exc
-#define subsystem_to_name_map_exc \
-    { "exception_raise", 2401 },\
-    { "exception_raise_state", 2402 },\
-    { "exception_raise_state_identity", 2403 }
-#endif
-
-#ifdef __AfterMigUserHeader
-__AfterMigUserHeader
-#endif /* __AfterMigUserHeader */
-
-#endif	 /* _exc_user_ */

toolkit/crashreporter/google-breakpad/src/client/mac/handler/breakpad_nlist_64.cc

@@ -67,6 +67,7 @@
 
 #include "breakpad_nlist_64.h"
 
+#include <CoreFoundation/CoreFoundation.h>
 #include <fcntl.h>
 #include <mach-o/nlist.h>
 #include <mach-o/loader.h>
@@ -189,25 +190,25 @@ int __breakpad_fdnlist(int fd, nlist_type *list, const char **symbolNames,
 
   struct exec buf;
   if (read(fd, (char *)&buf, sizeof(buf)) != sizeof(buf) ||
-      (N_BADMAG(buf) && *((long *)&buf) != magic &&
-       NXSwapBigLongToHost(*((long *)&buf)) != FAT_MAGIC) &&
-      /* The following is the big-endian ppc64 check */
-      (*((long*)&buf)) != FAT_MAGIC) {
+      (N_BADMAG(buf) && *((uint32_t *)&buf) != magic &&
+        CFSwapInt32BigToHost(*((uint32_t *)&buf)) != FAT_MAGIC &&
+       /* The following is the big-endian ppc64 check */
+       (*((uint32_t*)&buf)) != FAT_MAGIC)) {
     return -1;
   }
 
   /* Deal with fat file if necessary */
   unsigned arch_offset = 0;
-  if (NXSwapBigLongToHost(*((long *)&buf)) == FAT_MAGIC ||
+  if (CFSwapInt32BigToHost(*((uint32_t *)&buf)) == FAT_MAGIC ||
       /* The following is the big-endian ppc64 check */
       *((unsigned int *)&buf) == FAT_MAGIC) {
     /* Get host info */
     host_t host = mach_host_self();
-    unsigned i = HOST_BASIC_INFO_COUNT;
+    unsigned hic = HOST_BASIC_INFO_COUNT;
     struct host_basic_info hbi;
     kern_return_t kr;
     if ((kr = host_info(host, HOST_BASIC_INFO,
-                        (host_info_t)(&hbi), &i)) != KERN_SUCCESS) {
+                        (host_info_t)(&hbi), &hic)) != KERN_SUCCESS) {
       return -1;
     }
     mach_port_deallocate(mach_task_self(), host);
@@ -222,7 +223,7 @@ int __breakpad_fdnlist(int fd, nlist_type *list, const char **symbolNames,
     }
 
     /* Convert fat_narchs to host byte order */
-    fh.nfat_arch = NXSwapBigIntToHost(fh.nfat_arch);
+    fh.nfat_arch = CFSwapInt32BigToHost(fh.nfat_arch);
 
     /* Read in the fat archs */
     struct fat_arch *fat_archs =
@@ -232,7 +233,7 @@ int __breakpad_fdnlist(int fd, nlist_type *list, const char **symbolNames,
     }
     if (read(fd, (char *)fat_archs,
              sizeof(struct fat_arch) * fh.nfat_arch) !=
-        (ssize_t)sizeof(struct fat_arch) * fh.nfat_arch) {
+        (ssize_t)(sizeof(struct fat_arch) * fh.nfat_arch)) {
       free(fat_archs);
       return -1;
     }
@@ -243,15 +244,15 @@ int __breakpad_fdnlist(int fd, nlist_type *list, const char **symbolNames,
      */
     for (unsigned i = 0; i < fh.nfat_arch; i++) {
       fat_archs[i].cputype =
-        NXSwapBigIntToHost(fat_archs[i].cputype);
+        CFSwapInt32BigToHost(fat_archs[i].cputype);
       fat_archs[i].cpusubtype =
-        NXSwapBigIntToHost(fat_archs[i].cpusubtype);
+        CFSwapInt32BigToHost(fat_archs[i].cpusubtype);
       fat_archs[i].offset =
-        NXSwapBigIntToHost(fat_archs[i].offset);
+        CFSwapInt32BigToHost(fat_archs[i].offset);
       fat_archs[i].size =
-        NXSwapBigIntToHost(fat_archs[i].size);
+        CFSwapInt32BigToHost(fat_archs[i].size);
       fat_archs[i].align =
-        NXSwapBigIntToHost(fat_archs[i].align);
+        CFSwapInt32BigToHost(fat_archs[i].align);
     }
 
     struct fat_arch *fap = NULL;
@@ -296,7 +297,7 @@ int __breakpad_fdnlist(int fd, nlist_type *list, const char **symbolNames,
       return -1;
     }
     if (read(fd, (char *)load_commands, mh.sizeofcmds) !=
-        mh.sizeofcmds) {
+        (ssize_t)mh.sizeofcmds) {
       free(load_commands);
       return -1;
     }
@@ -304,7 +305,7 @@ int __breakpad_fdnlist(int fd, nlist_type *list, const char **symbolNames,
     struct load_command *lcp = load_commands;
     // iterate through all load commands, looking for
     // LC_SYMTAB load command
-    for (long i = 0; i < mh.ncmds; i++) {
+    for (uint32_t i = 0; i < mh.ncmds; i++) {
       if (lcp->cmdsize % sizeof(word_type) != 0 ||
           lcp->cmdsize <= 0 ||
           (char *)lcp + lcp->cmdsize >
@@ -360,7 +361,7 @@ int __breakpad_fdnlist(int fd, nlist_type *list, const char **symbolNames,
     if (read(fd, (char *)space, m) != m)
       break;
     n -= m;
-    long savpos = lseek(fd, 0, SEEK_CUR);
+    off_t savpos = lseek(fd, 0, SEEK_CUR);
     if (savpos == -1) {
       return -1;
     }

toolkit/crashreporter/google-breakpad/src/client/mac/handler/dynamic_images.cc

@@ -35,16 +35,43 @@ extern "C" { // needed to compile on Leopard
   #include <stdio.h>
 }
 
-#include "breakpad_nlist_64.h"
 #include <assert.h>
+#include <AvailabilityMacros.h>
 #include <dlfcn.h>
-#include <mach/mach_vm.h>
+#include <mach/task_info.h>
 #include <sys/sysctl.h>
+#include <TargetConditionals.h>
 
 #include <algorithm>
 #include <string>
 #include <vector>
 
+#include "breakpad_nlist_64.h"
+
+#if !TARGET_OS_IPHONE
+#include <CoreServices/CoreServices.h>
+
+#ifndef MAC_OS_X_VERSION_10_6
+#define MAC_OS_X_VERSION_10_6 1060
+#endif
+
+#if MAC_OS_X_VERSION_MAX_ALLOWED < MAC_OS_X_VERSION_10_6
+
+// Fallback declarations for TASK_DYLD_INFO and friends, introduced in
+// <mach/task_info.h> in the Mac OS X 10.6 SDK.
+#define TASK_DYLD_INFO 17
+struct task_dyld_info {
+  mach_vm_address_t all_image_info_addr;
+  mach_vm_size_t all_image_info_size;
+};
+typedef struct task_dyld_info task_dyld_info_data_t;
+typedef struct task_dyld_info *task_dyld_info_t;
+#define TASK_DYLD_INFO_COUNT (sizeof(task_dyld_info_data_t) / sizeof(natural_t))
+
+#endif
+
+#endif  // !TARGET_OS_IPHONE
+
 namespace google_breakpad {
 
 using std::string;
@@ -234,8 +261,8 @@ bool FindTextSection(DynamicImage& image) {
             reinterpret_cast<const mach_segment_command_type *>(cmd);
 
         if (!strcmp(seg->segname, "__TEXT")) {
-          image.vmaddr_ = seg->vmaddr;
-          image.vmsize_ = seg->vmsize;
+          image.vmaddr_ = static_cast<mach_vm_address_t>(seg->vmaddr);
+          image.vmsize_ = static_cast<mach_vm_size_t>(seg->vmsize);
           image.slide_ = 0;
 
           if (seg->fileoff == 0 && seg->filesize != 0) {
@@ -336,13 +363,49 @@ static uint64_t LookupSymbol(const char* symbol_name,
   return list.n_value;
 }
 
-uint64_t DynamicImages::GetDyldAllImageInfosPointer() {
-  const char *imageSymbolName = "_dyld_all_image_infos";
-  const char *dyldPath = "/usr/lib/dyld";
+#if TARGET_OS_IPHONE
+static bool HasTaskDyldInfo() {
+  return true;
+}
+#else
+static SInt32 GetOSVersionInternal() {
+  SInt32 os_version = 0;
+  Gestalt(gestaltSystemVersion, &os_version);
+  return os_version;
+}
 
-  if (Is64Bit())
-    return LookupSymbol<MachO64>(imageSymbolName, dyldPath, cpu_type_);
-  return LookupSymbol<MachO32>(imageSymbolName, dyldPath, cpu_type_);
+static SInt32 GetOSVersion() {
+  static SInt32 os_version = GetOSVersionInternal();
+  return os_version;
+}
+
+static bool HasTaskDyldInfo() {
+#if MAC_OS_X_VERSION_MIN_REQUIRED >= MAC_OS_X_VERSION_10_6
+  return true;
+#else
+  return GetOSVersion() >= 0x1060;
+#endif
+}
+#endif  // TARGET_OS_IPHONE
+
+uint64_t DynamicImages::GetDyldAllImageInfosPointer() {
+  if (HasTaskDyldInfo()) {
+    task_dyld_info_data_t task_dyld_info;
+    mach_msg_type_number_t count = TASK_DYLD_INFO_COUNT;
+    if (task_info(task_, TASK_DYLD_INFO, (task_info_t)&task_dyld_info,
+                  &count) != KERN_SUCCESS) {
+      return 0;
+    }
+
+    return (uint64_t)task_dyld_info.all_image_info_addr;
+  } else {
+    const char *imageSymbolName = "_dyld_all_image_infos";
+    const char *dyldPath = "/usr/lib/dyld";
+
+    if (Is64Bit())
+      return LookupSymbol<MachO64>(imageSymbolName, dyldPath, cpu_type_);
+    return LookupSymbol<MachO32>(imageSymbolName, dyldPath, cpu_type_);
+  }
 }
 
 //==============================================================================
@@ -429,7 +492,7 @@ void ReadImageInfo(DynamicImages& images,
                                    header_size,
                                    info.load_address_,
                                    file_path,
-                                   info.file_mod_date_,
+                                   static_cast<uintptr_t>(info.file_mod_date_),
                                    images.task_,
                                    images.cpu_type_);
 

toolkit/crashreporter/google-breakpad/src/client/mac/handler/dynamic_images.h

@@ -45,6 +45,8 @@
 #include <string>
 #include <vector>
 
+#include "mach_vm_compat.h"
+
 namespace google_breakpad {
 
 using std::string;
@@ -281,6 +283,8 @@ class DynamicImages {
     return CPU_TYPE_POWERPC;
 #elif defined(__ppc64__)
     return CPU_TYPE_POWERPC64;
+#elif defined(__arm__)
+    return CPU_TYPE_ARM;
 #else
 #error "GetNativeCPUType not implemented for this architecture"
 #endif

toolkit/crashreporter/google-breakpad/src/client/mac/handler/exception_handler.cc

@@ -28,16 +28,25 @@
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include <map>
+#include <mach/exc.h>
+#include <mach/mig.h>
 #include <pthread.h>
+#include <signal.h>
+#include <TargetConditionals.h>
 
 #include "client/mac/handler/exception_handler.h"
 #include "client/mac/handler/minidump_generator.h"
 #include "common/mac/macho_utilities.h"
 #include "common/mac/scoped_task_suspend-inl.h"
+#include "google_breakpad/common/minidump_exception_mac.h"
 
 #ifndef USE_PROTECTED_ALLOCATIONS
+#if TARGET_OS_IPHONE
+#define USE_PROTECTED_ALLOCATIONS 1
+#else
 #define USE_PROTECTED_ALLOCATIONS 0
 #endif
+#endif
 
 // If USE_PROTECTED_ALLOCATIONS is activated then the
 // gBreakpadAllocator needs to be setup in other code
@@ -48,18 +57,16 @@
   extern ProtectedMemoryAllocator *gBreakpadAllocator;
 #endif
 
-
 namespace google_breakpad {
 
-using std::map;
+static union {
+#if USE_PROTECTED_ALLOCATIONS
+  char protected_buffer[PAGE_SIZE] __attribute__((aligned(PAGE_SIZE)));
+#endif
+  google_breakpad::ExceptionHandler *handler;
+} gProtectedData;
 
-// Message ID telling the handler thread to write a dump.
-static const mach_msg_id_t kWriteDumpMessage = 0;
-// Message ID telling the handler thread to quit.
-static const mach_msg_id_t kQuitMessage = 1;
-// Message ID telling the handler thread to write a dump and include
-// an exception stream.
-static const mach_msg_id_t kWriteDumpWithExceptionMessage = 2;
+using std::map;
 
 // These structures and techniques are illustrated in
 // Mac OS X Internals, Amit Singh, ch 9.7
@@ -95,6 +102,7 @@ struct ExceptionReplyMessage {
 exception_mask_t s_exception_mask = EXC_MASK_BAD_ACCESS |
 EXC_MASK_BAD_INSTRUCTION | EXC_MASK_ARITHMETIC | EXC_MASK_BREAKPOINT;
 
+#if !TARGET_OS_IPHONE
 extern "C"
 {
   // Forward declarations for functions that need "C" style compilation
@@ -110,128 +118,98 @@ extern "C"
                                       exception_data_t code,
                                       mach_msg_type_number_t code_count)
       __attribute__((visibility("default")));
+}
+#endif
 
-  kern_return_t ForwardException(mach_port_t task,
-                                 mach_port_t failed_thread,
-                                 exception_type_t exception,
-                                 exception_data_t code,
-                                 mach_msg_type_number_t code_count);
+kern_return_t ForwardException(mach_port_t task,
+                               mach_port_t failed_thread,
+                               exception_type_t exception,
+                               exception_data_t code,
+                               mach_msg_type_number_t code_count);
 
-  kern_return_t exception_raise(mach_port_t target_port,
-                                mach_port_t failed_thread,
-                                mach_port_t task,
-                                exception_type_t exception,
-                                exception_data_t exception_code,
-                                mach_msg_type_number_t exception_code_count);
+#if TARGET_OS_IPHONE
+// Implementation is based on the implementation generated by mig.
+boolean_t breakpad_exc_server(mach_msg_header_t *InHeadP,
+                              mach_msg_header_t *OutHeadP) {
+   OutHeadP->msgh_bits =
+       MACH_MSGH_BITS(MACH_MSGH_BITS_REMOTE(InHeadP->msgh_bits), 0);
+   OutHeadP->msgh_remote_port = InHeadP->msgh_remote_port;
+   /* Minimal size: routine() will update it if different */
+   OutHeadP->msgh_size = (mach_msg_size_t)sizeof(mig_reply_error_t);
+   OutHeadP->msgh_local_port = MACH_PORT_NULL;
+   OutHeadP->msgh_id = InHeadP->msgh_id + 100;
 
-  kern_return_t
-    exception_raise_state(mach_port_t target_port,
-                          mach_port_t failed_thread,
-                          mach_port_t task,
-                          exception_type_t exception,
-                          exception_data_t exception_code,
-                          mach_msg_type_number_t code_count,
-                          thread_state_flavor_t *target_flavor,
-                          thread_state_t in_thread_state,
-                          mach_msg_type_number_t in_thread_state_count,
-                          thread_state_t out_thread_state,
-                          mach_msg_type_number_t *out_thread_state_count);
+  if (InHeadP->msgh_id != 2401) {
+    ((mig_reply_error_t *)OutHeadP)->NDR = NDR_record;
+    ((mig_reply_error_t *)OutHeadP)->RetCode = MIG_BAD_ID;
+    return FALSE;
+  }
 
-  kern_return_t
-    exception_raise_state_identity(mach_port_t target_port,
-                                   mach_port_t failed_thread,
-                                   mach_port_t task,
-                                   exception_type_t exception,
-                                   exception_data_t exception_code,
-                                   mach_msg_type_number_t exception_code_count,
-                                   thread_state_flavor_t *target_flavor,
-                                   thread_state_t in_thread_state,
-                                   mach_msg_type_number_t in_thread_state_count,
-                                   thread_state_t out_thread_state,
-                                   mach_msg_type_number_t *out_thread_state_count);
+#ifdef  __MigPackStructs
+#pragma pack(4)
+#endif
+  typedef struct {
+    mach_msg_header_t Head;
+    /* start of the kernel processed data */
+    mach_msg_body_t msgh_body;
+    mach_msg_port_descriptor_t thread;
+    mach_msg_port_descriptor_t task;
+    /* end of the kernel processed data */
+    NDR_record_t NDR;
+    exception_type_t exception;
+    mach_msg_type_number_t codeCnt;
+    integer_t code[2];
+    mach_msg_trailer_t trailer;
+  } Request;
 
-  kern_return_t breakpad_exception_raise_state(mach_port_t exception_port,
-                                               exception_type_t exception,
-                                               const exception_data_t code,
-                                               mach_msg_type_number_t codeCnt,
-                                               int *flavor,
-                                               const thread_state_t old_state,
-                                               mach_msg_type_number_t old_stateCnt,
-                                               thread_state_t new_state,
-                                               mach_msg_type_number_t *new_stateCnt
-                                               );
+  typedef struct {
+    mach_msg_header_t Head;
+    NDR_record_t NDR;
+    kern_return_t RetCode;
+  } Reply;
+#ifdef  __MigPackStructs
+#pragma pack()
+#endif
 
-  kern_return_t breakpad_exception_raise_state_identity(mach_port_t exception_port,
-                                                        mach_port_t thread,
-                                                        mach_port_t task,
-                                                        exception_type_t exception,
-                                                        exception_data_t code,
-                                                        mach_msg_type_number_t codeCnt,
-                                                        int *flavor,
-                                                        thread_state_t old_state,
-                                                        mach_msg_type_number_t old_stateCnt,
-                                                        thread_state_t new_state,
-                                                        mach_msg_type_number_t *new_stateCnt
-                                                        );
+  Request *In0P = (Request *)InHeadP;
+  Reply *OutP = (Reply *)OutHeadP;
 
-  kern_return_t breakpad_exception_raise(mach_port_t port, mach_port_t failed_thread,
-                                         mach_port_t task,
-                                         exception_type_t exception,
-                                         exception_data_t code,
-                                         mach_msg_type_number_t code_count);
+  if (In0P->task.name != mach_task_self()) {
+    return FALSE;
+  }
+  OutP->RetCode = ForwardException(In0P->task.name,
+                                   In0P->thread.name,
+                                   In0P->exception,
+                                   In0P->code,
+                                   In0P->codeCnt);
+  OutP->NDR = NDR_record;
+  return TRUE;
+}
+#else
+boolean_t breakpad_exc_server(mach_msg_header_t *request,
+                              mach_msg_header_t *reply) {
+  return exc_server(request, reply);
 }
 
-
-
-kern_return_t breakpad_exception_raise_state(mach_port_t exception_port,
-					     exception_type_t exception,
-					     const exception_data_t code,
-					     mach_msg_type_number_t codeCnt,
-					     int *flavor,
-					     const thread_state_t old_state,
-					     mach_msg_type_number_t old_stateCnt,
-					     thread_state_t new_state,
-					     mach_msg_type_number_t *new_stateCnt
-                                             )
-{
-  return KERN_SUCCESS;
-}
-
-kern_return_t breakpad_exception_raise_state_identity(mach_port_t exception_port,
-						      mach_port_t thread,
-						      mach_port_t task,
-						      exception_type_t exception,
-						      exception_data_t code,
-						      mach_msg_type_number_t codeCnt,
-						      int *flavor,
-						      thread_state_t old_state,
-						      mach_msg_type_number_t old_stateCnt,
-						      thread_state_t new_state,
-						      mach_msg_type_number_t *new_stateCnt
-                                                      )
-{
-  return KERN_SUCCESS;
-}
-
-kern_return_t breakpad_exception_raise(mach_port_t port, mach_port_t failed_thread,
-                                       mach_port_t task,
-                                       exception_type_t exception,
-                                       exception_data_t code,
-                                       mach_msg_type_number_t code_count) {
-
+// Callback from exc_server()
+kern_return_t catch_exception_raise(mach_port_t port, mach_port_t failed_thread,
+                                    mach_port_t task,
+                                    exception_type_t exception,
+                                    exception_data_t code,
+                                    mach_msg_type_number_t code_count) {
   if (task != mach_task_self()) {
     return KERN_FAILURE;
   }
   return ForwardException(task, failed_thread, exception, code, code_count);
 }
-
+#endif
 
 ExceptionHandler::ExceptionHandler(const string &dump_path,
                                    FilterCallback filter,
                                    MinidumpCallback callback,
                                    void *callback_context,
                                    bool install_handler,
-				   const char *port_name)
+                                   const char *port_name)
     : dump_path_(),
       filter_(filter),
       callback_(callback),
@@ -247,8 +225,10 @@ ExceptionHandler::ExceptionHandler(const string &dump_path,
   // This will update to the ID and C-string pointers
   set_dump_path(dump_path);
   MinidumpGenerator::GatherSystemInformation();
+#if !TARGET_OS_IPHONE
   if (port_name)
     crash_generation_client_.reset(new CrashGenerationClient(port_name));
+#endif
   Setup(install_handler);
 }
 
@@ -290,8 +270,8 @@ bool ExceptionHandler::WriteMinidump(bool write_exception_stream) {
     // Send an empty message to the handle port so that a minidump will
     // be written
     SendMessageToHandlerThread(write_exception_stream ?
-                               kWriteDumpWithExceptionMessage
-                               : kWriteDumpMessage);
+                                   kWriteDumpWithExceptionMessage :
+                                   kWriteDumpMessage);
 
     // Wait for the minidump writer to complete its writing.  It will unlock
     // the mutex when completed
@@ -330,8 +310,10 @@ bool ExceptionHandler::WriteMinidumpForChild(mach_port_t child,
 				    EXC_I386_BPT,
 #elif defined (__ppc__) || defined (__ppc64__)
 				    EXC_PPC_BREAKPOINT,
+#elif defined (__arm__)
+				    EXC_ARM_BREAKPOINT,
 #else
-  #error architecture not supported
+#error architecture not supported
 #endif
 				    0,
 				    child_blamed_thread);
@@ -347,8 +329,10 @@ bool ExceptionHandler::WriteMinidumpForChild(mach_port_t child,
 bool ExceptionHandler::WriteMinidumpWithException(int exception_type,
                                                   int exception_code,
                                                   int exception_subcode,
+                                                  ucontext_t *task_context,
                                                   mach_port_t thread_name,
-                                                  bool exit_after_write) {
+                                                  bool exit_after_write,
+                                                  bool report_current_thread) {
   bool result = false;
 
   if (directCallback_) {
@@ -360,6 +344,7 @@ bool ExceptionHandler::WriteMinidumpWithException(int exception_type,
       if (exit_after_write)
         _exit(exception_type);
     }
+#if !TARGET_OS_IPHONE
   } else if (IsOutOfProcess()) {
     if (exception_type && exception_code) {
       // If this is a real exception, give the filter (if any) a chance to
@@ -372,13 +357,17 @@ bool ExceptionHandler::WriteMinidumpWithException(int exception_type,
 		 exception_subcode,
 		 thread_name);
     }
+#endif
   } else {
     string minidump_id;
 
     // Putting the MinidumpGenerator in its own context will ensure that the
     // destructor is executed, closing the newly created minidump file.
     if (!dump_path_.empty()) {
-      MinidumpGenerator md;
+      MinidumpGenerator md(mach_task_self(),
+                           report_current_thread ? MACH_PORT_NULL :
+                                                   mach_thread_self());
+      md.SetTaskContext(task_context);
       if (exception_type && exception_code) {
         // If this is a real exception, give the filter (if any) a chance to
         // decide if this should be sent.
@@ -419,13 +408,13 @@ kern_return_t ForwardException(mach_port_t task, mach_port_t failed_thread,
 
   current.count = EXC_TYPES_COUNT;
   mach_port_t current_task = mach_task_self();
-  kern_return_t result = task_get_exception_ports(current_task,
-                                                  s_exception_mask,
-                                                  current.masks,
-                                                  &current.count,
-                                                  current.ports,
-                                                  current.behaviors,
-                                                  current.flavors);
+  task_get_exception_ports(current_task,
+                           s_exception_mask,
+                           current.masks,
+                           &current.count,
+                           current.ports,
+                           current.behaviors,
+                           current.flavors);
 
   // Find the first exception handler that matches the exception
   unsigned int found;
@@ -443,48 +432,16 @@ kern_return_t ForwardException(mach_port_t task, mach_port_t failed_thread,
 
   mach_port_t target_port = current.ports[found];
   exception_behavior_t target_behavior = current.behaviors[found];
-  thread_state_flavor_t target_flavor = current.flavors[found];
 
-  mach_msg_type_number_t thread_state_count = THREAD_STATE_MAX;
-  breakpad_thread_state_data_t thread_state;
+  kern_return_t result;
   switch (target_behavior) {
     case EXCEPTION_DEFAULT:
       result = exception_raise(target_port, failed_thread, task, exception,
                                code, code_count);
       break;
 
-    case EXCEPTION_STATE:
-      result = thread_get_state(failed_thread, target_flavor, thread_state,
-                                &thread_state_count);
-      if (result == KERN_SUCCESS)
-        result = exception_raise_state(target_port, failed_thread, task,
-                                       exception, code,
-                                       code_count, &target_flavor,
-                                       thread_state, thread_state_count,
-                                       thread_state, &thread_state_count);
-      if (result == KERN_SUCCESS)
-        result = thread_set_state(failed_thread, target_flavor, thread_state,
-                                  thread_state_count);
-      break;
-
-    case EXCEPTION_STATE_IDENTITY:
-      result = thread_get_state(failed_thread, target_flavor, thread_state,
-                                &thread_state_count);
-      if (result == KERN_SUCCESS)
-        result = exception_raise_state_identity(target_port, failed_thread,
-                                                task, exception, code,
-                                                code_count, &target_flavor,
-                                                thread_state,
-                                                thread_state_count,
-                                                thread_state,
-                                                &thread_state_count);
-      if (result == KERN_SUCCESS)
-        result = thread_set_state(failed_thread, target_flavor, thread_state,
-                                  thread_state_count);
-      break;
-
     default:
-      fprintf(stderr, "** Unknown exception behavior\n");
+      fprintf(stderr, "** Unknown exception behavior: %d\n", target_behavior);
       result = KERN_FAILURE;
       break;
   }
@@ -492,18 +449,6 @@ kern_return_t ForwardException(mach_port_t task, mach_port_t failed_thread,
   return result;
 }
 
-// Callback from exc_server()
-kern_return_t catch_exception_raise(mach_port_t port, mach_port_t failed_thread,
-                                    mach_port_t task,
-                                    exception_type_t exception,
-                                    exception_data_t code,
-                                    mach_msg_type_number_t code_count) {
-  if (task != mach_task_self()) {
-    return KERN_FAILURE;
-  }
-  return ForwardException(task, failed_thread, exception, code, code_count);
-}
-
 // static
 void *ExceptionHandler::WaitForMessage(void *exception_handler_class) {
   ExceptionHandler *self =
@@ -536,13 +481,13 @@ void *ExceptionHandler::WaitForMessage(void *exception_handler_class) {
       if (!receive.exception) {
         // Don't touch self, since this message could have been sent
         // from its destructor.
-        if (receive.header.msgh_id == kQuitMessage)
+        if (receive.header.msgh_id == kShutdownMessage)
           return NULL;
 
         self->SuspendThreads();
 
 #if USE_PROTECTED_ALLOCATIONS
-        if(gBreakpadAllocator)
+        if (gBreakpadAllocator)
           gBreakpadAllocator->Unprotect();
 #endif
 
@@ -556,21 +501,21 @@ void *ExceptionHandler::WaitForMessage(void *exception_handler_class) {
           exception_code = EXC_I386_BPT;
 #elif defined (__ppc__) || defined (__ppc64__)
           exception_code = EXC_PPC_BREAKPOINT;
+#elif defined (__arm__)
+          exception_code = EXC_ARM_BREAKPOINT;
 #else
-  #error architecture not supported
+#error architecture not supported
 #endif
         }
 
         // Write out the dump and save the result for later retrieval
         self->last_minidump_write_result_ =
           self->WriteMinidumpWithException(exception_type, exception_code,
-                                           0, thread,
-                                           exception_type != EXC_BREAKPOINT);
-
-        self->UninstallHandler(false);
+                                           0, NULL, thread,
+                                           false, false);
 
 #if USE_PROTECTED_ALLOCATIONS
-        if(gBreakpadAllocator)
+        if (gBreakpadAllocator)
           gBreakpadAllocator->Protect();
 #endif
 
@@ -585,13 +530,13 @@ void *ExceptionHandler::WaitForMessage(void *exception_handler_class) {
         // exceptions that occur in the parent process are caught and
         // processed.  If the exception was not caused by this task, we
         // still need to call into the exception server and have it return
-        // KERN_FAILURE (see breakpad_exception_raise) in order for the kernel
+        // KERN_FAILURE (see catch_exception_raise) in order for the kernel
         // to move onto the host exception handler for the child task
         if (receive.task.name == mach_task_self()) {
           self->SuspendThreads();
 
 #if USE_PROTECTED_ALLOCATIONS
-        if(gBreakpadAllocator)
+        if (gBreakpadAllocator)
           gBreakpadAllocator->Unprotect();
 #endif
 
@@ -601,26 +546,35 @@ void *ExceptionHandler::WaitForMessage(void *exception_handler_class) {
 
         // Generate the minidump with the exception data.
         self->WriteMinidumpWithException(receive.exception, receive.code[0],
-                                         subcode, receive.thread.name, true);
+                                         subcode, NULL, receive.thread.name,
+                                         true, false);
+
+#if USE_PROTECTED_ALLOCATIONS
+        // This may have become protected again within
+        // WriteMinidumpWithException, but it needs to be unprotected for
+        // UninstallHandler.
+        if (gBreakpadAllocator)
+          gBreakpadAllocator->Unprotect();
+#endif
 
         self->UninstallHandler(true);
 
 #if USE_PROTECTED_ALLOCATIONS
-        if(gBreakpadAllocator)
+        if (gBreakpadAllocator)
           gBreakpadAllocator->Protect();
 #endif
         }
         // Pass along the exception to the server, which will setup the
-        // message and call breakpad_exception_raise() and put the return
+        // message and call catch_exception_raise() and put the return
         // code into the reply.
         ExceptionReplyMessage reply;
-        if (!exc_server(&receive.header, &reply.header))
+        if (!breakpad_exc_server(&receive.header, &reply.header))
           exit(1);
 
         // Send a reply and exit
-        result = mach_msg(&(reply.header), MACH_SEND_MSG,
-                          reply.header.msgh_size, 0, MACH_PORT_NULL,
-                          MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
+        mach_msg(&(reply.header), MACH_SEND_MSG,
+                 reply.header.msgh_size, 0, MACH_PORT_NULL,
+                 MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
       }
     }
   }
@@ -628,7 +582,53 @@ void *ExceptionHandler::WaitForMessage(void *exception_handler_class) {
   return NULL;
 }
 
+//static
+void ExceptionHandler::SignalHandler(int sig, siginfo_t* info, void* uc) {
+#if USE_PROTECTED_ALLOCATIONS
+  if (gBreakpadAllocator)
+    gBreakpadAllocator->Unprotect();
+#endif
+  gProtectedData.handler->WriteMinidumpWithException(
+      EXC_SOFTWARE,
+      MD_EXCEPTION_CODE_MAC_ABORT,
+      0,
+      static_cast<ucontext_t*>(uc),
+      mach_thread_self(),
+      true,
+      true);
+#if USE_PROTECTED_ALLOCATIONS
+  if (gBreakpadAllocator)
+    gBreakpadAllocator->Protect();
+#endif
+}
+
 bool ExceptionHandler::InstallHandler() {
+  // If a handler is already installed, something is really wrong.
+  if (gProtectedData.handler != NULL) {
+    return false;
+  }
+#if TARGET_OS_IPHONE
+  if (!IsOutOfProcess()) {
+    struct sigaction sa;
+    memset(&sa, 0, sizeof(sa));
+    sigemptyset(&sa.sa_mask);
+    sigaddset(&sa.sa_mask, SIGABRT);
+    sa.sa_sigaction = ExceptionHandler::SignalHandler;
+    sa.sa_flags = SA_SIGINFO;
+
+    scoped_ptr<struct sigaction> old(new struct sigaction);
+    if (sigaction(SIGABRT, &sa, old.get()) == -1) {
+      return false;
+    }
+    old_handler_.swap(old);
+    gProtectedData.handler = this;
+#if USE_PROTECTED_ALLOCATIONS
+    assert(((size_t)(gProtectedData.protected_buffer) & PAGE_MASK) == 0);
+    mprotect(gProtectedData.protected_buffer, PAGE_SIZE, PROT_READ);
+#endif
+  }
+#endif
+
   try {
 #if USE_PROTECTED_ALLOCATIONS
     previous_ = new (gBreakpadAllocator->Allocate(sizeof(ExceptionParameters)) )
@@ -667,6 +667,16 @@ bool ExceptionHandler::InstallHandler() {
 bool ExceptionHandler::UninstallHandler(bool in_exception) {
   kern_return_t result = KERN_SUCCESS;
 
+  if (old_handler_.get()) {
+    sigaction(SIGABRT, old_handler_.get(), NULL);
+#if USE_PROTECTED_ALLOCATIONS
+    mprotect(gProtectedData.protected_buffer, PAGE_SIZE,
+        PROT_READ | PROT_WRITE);
+#endif
+    old_handler_.reset();
+    gProtectedData.handler = NULL;
+  }
+
   if (installed_exception_handler_) {
     mach_port_t current_task = mach_task_self();
 
@@ -736,7 +746,7 @@ bool ExceptionHandler::Teardown() {
     return false;
 
   // Send an empty message so that the handler_thread exits
-  if (SendMessageToHandlerThread(kQuitMessage)) {
+  if (SendMessageToHandlerThread(kShutdownMessage)) {
     mach_port_t current_task = mach_task_self();
     result = mach_port_deallocate(current_task, handler_port_);
     if (result != KERN_SUCCESS)
@@ -746,13 +756,14 @@ bool ExceptionHandler::Teardown() {
   }
 
   handler_thread_ = NULL;
-  handler_port_ = NULL;
+  handler_port_ = MACH_PORT_NULL;
   pthread_mutex_destroy(&minidump_write_mutex_);
 
   return result == KERN_SUCCESS;
 }
 
-bool ExceptionHandler::SendMessageToHandlerThread(mach_msg_id_t message_id) {
+bool ExceptionHandler::SendMessageToHandlerThread(
+    HandlerThreadMessage message_id) {
   ExceptionMessage msg;
   memset(&msg, 0, sizeof(msg));
   msg.header.msgh_id = message_id;

toolkit/crashreporter/google-breakpad/src/client/mac/handler/exception_handler.h

@@ -37,18 +37,32 @@
 #define CLIENT_MAC_HANDLER_EXCEPTION_HANDLER_H__
 
 #include <mach/mach.h>
+#include <TargetConditionals.h>
 
 #include <string>
 
-#include "client/mac/crash_generation/crash_generation_client.h"
 #include "processor/scoped_ptr.h"
 
+#if !TARGET_OS_IPHONE
+#include "client/mac/crash_generation/crash_generation_client.h"
+#endif
+
 namespace google_breakpad {
 
 using std::string;
 
 struct ExceptionParameters;
 
+enum HandlerThreadMessage {
+  // Message ID telling the handler thread to write a dump.
+  kWriteDumpMessage = 0,
+  // Message ID telling the handler thread to write a dump and include
+  // an exception stream.
+  kWriteDumpWithExceptionMessage = 1,
+  // Message ID telling the handler thread to quit.
+  kShutdownMessage = 2
+};
+
 class ExceptionHandler {
  public:
   // A callback function to run before Breakpad performs any substantial
@@ -142,7 +156,11 @@ class ExceptionHandler {
 
   // Returns whether out-of-process dump generation is used or not.
   bool IsOutOfProcess() const {
+#if TARGET_OS_IPHONE
+    return false;
+#else
     return crash_generation_client_.get() != NULL;
+#endif
   }
 
  private:
@@ -162,17 +180,26 @@ class ExceptionHandler {
 
   // Send a mach message to the exception handler.  Return true on
   // success, false otherwise.
-  bool SendMessageToHandlerThread(mach_msg_id_t message_id);
+  bool SendMessageToHandlerThread(HandlerThreadMessage message_id);
 
-  // All minidump writing goes through this one routine
-  bool WriteMinidumpWithException(int exception_type, int exception_code,
-                                  int exception_subcode, mach_port_t thread_name,
-                                  bool exit_after_write);
+  // All minidump writing goes through this one routine.
+  // |task_context| can be NULL. If not, it will be used to retrieve the
+  // context of the current thread, instead of using |thread_get_state|.
+  bool WriteMinidumpWithException(int exception_type,
+                                  int exception_code,
+                                  int exception_subcode,
+                                  ucontext_t *task_context,
+                                  mach_port_t thread_name,
+                                  bool exit_after_write,
+                                  bool report_current_thread);
 
   // When installed, this static function will be call from a newly created
   // pthread with |this| as the argument
   static void *WaitForMessage(void *exception_handler_class);
 
+  // Signal handler for SIGABRT.
+  static void SignalHandler(int sig, siginfo_t* info, void* uc);
+
   // disallow copy ctor and operator=
   explicit ExceptionHandler(const ExceptionHandler &);
   void operator=(const ExceptionHandler &);
@@ -238,8 +265,14 @@ class ExceptionHandler {
   // True, if we're using the mutext to indicate when mindump writing occurs
   bool use_minidump_write_mutex_;
 
+  // Old signal handler for SIGABRT. Used to be able to restore it when
+  // uninstalling.
+  scoped_ptr<struct sigaction> old_handler_;
+
+#if !TARGET_OS_IPHONE
   // Client for out-of-process dump generation.
   scoped_ptr<CrashGenerationClient> crash_generation_client_;
+#endif
 };
 
 }  // namespace google_breakpad

toolkit/crashreporter/google-breakpad/src/client/mac/handler/mach_vm_compat.h

@@ -0,0 +1,49 @@
+// Copyright (c) 2011, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef CLIENT_MAC_GENERATOR_MACH_VM_COMPAT_H_
+#define CLIENT_MAC_GENERATOR_MACH_VM_COMPAT_H_
+
+#include <TargetConditionals.h>
+
+// On iOS 5, mach/mach_vm.h is not supported anymore. As the architecture is 32
+// bits, we can use the simple vm_ functions instead of the mach_vm_ ones.
+#if TARGET_OS_IPHONE
+#include <mach/vm_map.h>
+#define mach_vm_address_t vm_address_t
+#define mach_vm_deallocate vm_deallocate
+#define mach_vm_read vm_read
+#define mach_vm_region vm_region
+#define mach_vm_region_recurse vm_region_recurse
+#define mach_vm_size_t vm_size_t
+#else
+#include <mach/mach_vm.h>
+#endif  // TARGET_OS_IPHONE
+
+#endif  // CLIENT_MAC_GENERATOR_MACH_VM_COMPAT_H_

toolkit/crashreporter/google-breakpad/src/client/mac/handler/minidump_generator.cc

@@ -31,8 +31,6 @@
 #include <cstdio>
 
 #include <mach/host_info.h>
-#include <mach/i386/thread_status.h>
-#include <mach/mach_vm.h>
 #include <mach/vm_statistics.h>
 #include <mach-o/dyld.h>
 #include <mach-o/loader.h>
@@ -43,12 +41,19 @@
 
 #include "client/mac/handler/minidump_generator.h"
 
+#ifdef HAS_ARM_SUPPORT
+#include <mach/arm/thread_status.h>
+#endif
 #ifdef HAS_PPC_SUPPORT
 #include <mach/ppc/thread_status.h>
 #endif
+#ifdef HAS_X86_SUPPORT
+#include <mach/i386/thread_status.h>
+#endif
 
 #include "client/minidump_file_writer-inl.h"
 #include "common/mac/file_id.h"
+#include "common/mac/macho_id.h"
 #include "common/mac/string_utilities.h"
 
 using MacStringUtils::ConvertToString;
@@ -72,6 +77,7 @@ MinidumpGenerator::MinidumpGenerator()
       crashing_task_(mach_task_self()),
       handler_thread_(mach_thread_self()),
       cpu_type_(DynamicImages::GetNativeCPUType()),
+      task_context_(NULL),
       dynamic_images_(NULL),
       memory_blocks_(&allocator_) {
   GatherSystemInformation();
@@ -89,6 +95,7 @@ MinidumpGenerator::MinidumpGenerator(mach_port_t crashing_task,
       crashing_task_(crashing_task),
       handler_thread_(handler_thread),
       cpu_type_(DynamicImages::GetNativeCPUType()),
+      task_context_(NULL),
       dynamic_images_(NULL),
       memory_blocks_(&allocator_) {
   if (crashing_task != mach_task_self()) {
@@ -130,14 +137,19 @@ void MinidumpGenerator::GatherSystemInformation() {
   CFURLCreateDataAndPropertiesFromResource(NULL, sys_vers, &data, NULL, NULL,
                                            &error);
 
-  if (!data)
+  if (!data) {
+    CFRelease(sys_vers);
     return;
+  }
 
   CFDictionaryRef list = static_cast<CFDictionaryRef>
     (CFPropertyListCreateFromXMLData(NULL, data, kCFPropertyListImmutable,
                                      NULL));
-  if (!list)
+  if (!list) {
+    CFRelease(sys_vers);
+    CFRelease(data);
     return;
+  }
 
   CFStringRef build_version = static_cast<CFStringRef>
     (CFDictionaryGetValue(list, CFSTR("ProductBuildVersion")));
@@ -158,6 +170,10 @@ void MinidumpGenerator::GatherSystemInformation() {
   os_build_number_ = IntegerValueAtIndex(product_str, 2);
 }
 
+void MinidumpGenerator::SetTaskContext(ucontext_t *task_context) {
+  task_context_ = task_context;
+}
+
 string MinidumpGenerator::UniqueNameInDirectory(const string &dir,
                                                 string *unique_name) {
   CFUUIDRef uuid = CFUUIDCreate(NULL);
@@ -255,37 +271,45 @@ size_t MinidumpGenerator::CalculateStackSize(mach_vm_address_t start_addr) {
   kern_return_t result =
     mach_vm_region_recurse(crashing_task_, &stack_region_base,
                            &stack_region_size, &nesting_level,
-                           region_info,
-                           &info_count);
+                           region_info, &info_count);
 
-  if (start_addr < stack_region_base) {
-    // probably stack corruption, since mach_vm_region had to go
+  if (result != KERN_SUCCESS || start_addr < stack_region_base) {
+    // Failure or stack corruption, since mach_vm_region had to go
     // higher in the process address space to find a valid region.
     return 0;
   }
 
-  if (((cpu_type_ & CPU_ARCH_ABI64) &&
-       (stack_region_base + stack_region_size) == TOP_OF_THREAD0_STACK_64BIT) ||
-      (!(cpu_type_ & CPU_ARCH_ABI64) &&
-       (stack_region_base + stack_region_size) == TOP_OF_THREAD0_STACK_32BIT)) {
-    // The stack for thread 0 needs to extend all the way to
-    // 0xc0000000 on 32 bit and 00007fff5fc00000 on 64bit.  HOWEVER,
-    // for many processes, the stack is first created in one page
-    // below this, and is then later extended to a much larger size by
-    // creating a new VM region immediately below the initial page.
+  unsigned int tag = submap_info.user_tag;
 
-    // You can see this for yourself by running vmmap on a "hello,
-    // world" program
+  // If the user tag is VM_MEMORY_STACK, look for more readable regions with
+  // the same tag placed immediately above the computed stack region. Under
+  // some circumstances, the stack for thread 0 winds up broken up into
+  // multiple distinct abutting regions. This can happen for several reasons,
+  // including user code that calls setrlimit(RLIMIT_STACK, ...) or changes
+  // the access on stack pages by calling mprotect.
+  if (tag == VM_MEMORY_STACK) {
+    while (true) {
+      mach_vm_address_t next_region_base = stack_region_base +
+                                           stack_region_size;
+      mach_vm_address_t proposed_next_region_base = next_region_base;
+      mach_vm_size_t next_region_size;
+      nesting_level = 0;
+      info_count = VM_REGION_SUBMAP_INFO_COUNT_64;
+      result = mach_vm_region_recurse(crashing_task_, &next_region_base,
+                                      &next_region_size, &nesting_level,
+                                      region_info, &info_count);
+      if (result != KERN_SUCCESS ||
+          next_region_base != proposed_next_region_base ||
+          submap_info.user_tag != tag ||
+          (submap_info.protection & VM_PROT_READ) == 0) {
+        break;
+      }
 
-    // Because of the above, we'll add 4k to include the original
-    // stack frame page.
-    // This method of finding the stack region needs to be done in
-    // a better way; the breakpad issue 247 is tracking this.
-    stack_region_size += 0x1000;
+      stack_region_size += next_region_size;
+    }
   }
 
-  return result == KERN_SUCCESS ?
-    stack_region_base + stack_region_size - start_addr : 0;
+  return stack_region_base + stack_region_size - start_addr;
 }
 
 bool MinidumpGenerator::WriteStackFromStartAddress(
@@ -340,16 +364,22 @@ bool MinidumpGenerator::WriteStackFromStartAddress(
 bool MinidumpGenerator::WriteStack(breakpad_thread_state_data_t state,
                                    MDMemoryDescriptor *stack_location) {
   switch (cpu_type_) {
-#ifdef HAS_PPC_SUUPORT
+#ifdef HAS_ARM_SUPPORT
+    case CPU_TYPE_ARM:
+      return WriteStackARM(state, stack_location);
+#endif
+#ifdef HAS_PPC_SUPPORT
     case CPU_TYPE_POWERPC:
       return WriteStackPPC(state, stack_location);
     case CPU_TYPE_POWERPC64:
       return WriteStackPPC64(state, stack_location);
 #endif
+#ifdef HAS_X86_SUPPORT
     case CPU_TYPE_I386:
       return WriteStackX86(state, stack_location);
     case CPU_TYPE_X86_64:
       return WriteStackX86_64(state, stack_location);
+#endif
     default:
       return false;
   }
@@ -358,16 +388,22 @@ bool MinidumpGenerator::WriteStack(breakpad_thread_state_data_t state,
 bool MinidumpGenerator::WriteContext(breakpad_thread_state_data_t state,
                                      MDLocationDescriptor *register_location) {
   switch (cpu_type_) {
+#ifdef HAS_ARM_SUPPORT
+    case CPU_TYPE_ARM:
+      return WriteContextARM(state, register_location);
+#endif
 #ifdef HAS_PPC_SUPPORT
     case CPU_TYPE_POWERPC:
       return WriteContextPPC(state, register_location);
     case CPU_TYPE_POWERPC64:
       return WriteContextPPC64(state, register_location);
 #endif
+#ifdef HAS_X86_SUPPORT
     case CPU_TYPE_I386:
       return WriteContextX86(state, register_location);
     case CPU_TYPE_X86_64:
       return WriteContextX86_64(state, register_location);
+#endif
     default:
       return false;
   }
@@ -376,22 +412,86 @@ bool MinidumpGenerator::WriteContext(breakpad_thread_state_data_t state,
 u_int64_t MinidumpGenerator::CurrentPCForStack(
     breakpad_thread_state_data_t state) {
   switch (cpu_type_) {
+#ifdef HAS_ARM_SUPPORT
+    case CPU_TYPE_ARM:
+      return CurrentPCForStackARM(state);
+#endif
 #ifdef HAS_PPC_SUPPORT
     case CPU_TYPE_POWERPC:
       return CurrentPCForStackPPC(state);
     case CPU_TYPE_POWERPC64:
       return CurrentPCForStackPPC64(state);
 #endif
+#ifdef HAS_X86_SUPPORT
     case CPU_TYPE_I386:
       return CurrentPCForStackX86(state);
     case CPU_TYPE_X86_64:
       return CurrentPCForStackX86_64(state);
+#endif
     default:
-      assert("Unknown CPU type!");
+      assert(0 && "Unknown CPU type!");
       return 0;
   }
 }
 
+#ifdef HAS_ARM_SUPPORT
+bool MinidumpGenerator::WriteStackARM(breakpad_thread_state_data_t state,
+                                      MDMemoryDescriptor *stack_location) {
+  arm_thread_state_t *machine_state =
+      reinterpret_cast<arm_thread_state_t *>(state);
+  mach_vm_address_t start_addr = REGISTER_FROM_THREADSTATE(machine_state, sp);
+  return WriteStackFromStartAddress(start_addr, stack_location);
+}
+
+u_int64_t
+MinidumpGenerator::CurrentPCForStackARM(breakpad_thread_state_data_t state) {
+  arm_thread_state_t *machine_state =
+      reinterpret_cast<arm_thread_state_t *>(state);
+
+  return REGISTER_FROM_THREADSTATE(machine_state, pc);
+}
+
+bool MinidumpGenerator::WriteContextARM(breakpad_thread_state_data_t state,
+                                        MDLocationDescriptor *register_location)
+{
+  TypedMDRVA<MDRawContextARM> context(&writer_);
+  arm_thread_state_t *machine_state =
+      reinterpret_cast<arm_thread_state_t *>(state);
+
+  if (!context.Allocate())
+    return false;
+
+  *register_location = context.location();
+  MDRawContextARM *context_ptr = context.get();
+  context_ptr->context_flags = MD_CONTEXT_ARM_FULL;
+
+#define AddGPR(a) context_ptr->iregs[a] = REGISTER_FROM_THREADSTATE(machine_state, r[a])
+
+  context_ptr->iregs[13] = REGISTER_FROM_THREADSTATE(machine_state, sp);
+  context_ptr->iregs[14] = REGISTER_FROM_THREADSTATE(machine_state, lr);
+  context_ptr->iregs[15] = REGISTER_FROM_THREADSTATE(machine_state, pc);
+  context_ptr->cpsr = REGISTER_FROM_THREADSTATE(machine_state, cpsr);
+
+  AddGPR(0);
+  AddGPR(1);
+  AddGPR(2);
+  AddGPR(3);
+  AddGPR(4);
+  AddGPR(5);
+  AddGPR(6);
+  AddGPR(7);
+  AddGPR(8);
+  AddGPR(9);
+  AddGPR(10);
+  AddGPR(11);
+  AddGPR(12);
+#undef AddReg
+#undef AddGPR
+
+  return true;
+}
+#endif
+
 #ifdef HAS_PCC_SUPPORT
 bool MinidumpGenerator::WriteStackPPC(breakpad_thread_state_data_t state,
                                       MDMemoryDescriptor *stack_location) {
@@ -552,6 +652,7 @@ bool MinidumpGenerator::WriteContextPPC64(
 
 #endif
 
+#ifdef HAS_X86_SUPPORT
 bool MinidumpGenerator::WriteStackX86(breakpad_thread_state_data_t state,
                                    MDMemoryDescriptor *stack_location) {
   i386_thread_state_t *machine_state =
@@ -620,7 +721,7 @@ bool MinidumpGenerator::WriteContextX86(breakpad_thread_state_data_t state,
   AddReg(eflags);
 
   AddReg(eip);
-#undef AddReg(a)
+#undef AddReg
 
   return true;
 }
@@ -666,16 +767,35 @@ bool MinidumpGenerator::WriteContextX86_64(
   AddReg(cs);
   AddReg(fs);
   AddReg(gs);
-#undef AddReg(a)
+#undef AddReg
 
   return true;
 }
+#endif
 
 bool MinidumpGenerator::GetThreadState(thread_act_t target_thread,
                                        thread_state_t state,
                                        mach_msg_type_number_t *count) {
+  if (task_context_ && target_thread == mach_thread_self()) {
+    switch (cpu_type_) {
+#ifdef HAS_ARM_SUPPORT
+      case CPU_TYPE_ARM: {
+        size_t final_size =
+            std::min(static_cast<size_t>(*count), sizeof(arm_thread_state_t));
+        memcpy(state, &task_context_->uc_mcontext->__ss, final_size);
+        *count = final_size;
+        return true;
+      }
+#endif
+    }
+  }
   thread_state_flavor_t flavor;
   switch (cpu_type_) {
+#ifdef HAS_ARM_SUPPORT
+    case CPU_TYPE_ARM:
+      flavor = ARM_THREAD_STATE;
+      break;
+#endif
 #ifdef HAS_PPC_SUPPORT
     case CPU_TYPE_POWERPC:
       flavor = PPC_THREAD_STATE;
@@ -684,12 +804,14 @@ bool MinidumpGenerator::GetThreadState(thread_act_t target_thread,
       flavor = PPC_THREAD_STATE64;
       break;
 #endif
+#ifdef HAS_X86_SUPPORT
     case CPU_TYPE_I386:
       flavor = i386_THREAD_STATE;
       break;
     case CPU_TYPE_X86_64:
       flavor = x86_THREAD_STATE64;
       break;
+#endif
     default:
       return false;
   }
@@ -775,26 +897,25 @@ bool MinidumpGenerator::WriteMemoryListStream(
     mach_msg_type_number_t stateCount
       = static_cast<mach_msg_type_number_t>(sizeof(state));
 
-    if (thread_get_state(exception_thread_,
-                         BREAKPAD_MACHINE_THREAD_STATE,
-                         state,
-                         &stateCount) == KERN_SUCCESS) {
+    if (GetThreadState(exception_thread_, state, &stateCount)) {
       u_int64_t ip = CurrentPCForStack(state);
       // Bound it to the upper and lower bounds of the region
       // it's contained within. If it's not in a known memory region,
       // don't bother trying to write it.
-      mach_vm_address_t addr = ip;
+      mach_vm_address_t addr = static_cast<vm_address_t>(ip);
       mach_vm_size_t size;
       natural_t nesting_level = 0;
       vm_region_submap_info_64 info;
       mach_msg_type_number_t info_count = VM_REGION_SUBMAP_INFO_COUNT_64;
+      vm_region_recurse_info_t recurse_info;
+      recurse_info = reinterpret_cast<vm_region_recurse_info_t>(&info);
 
       kern_return_t ret =
         mach_vm_region_recurse(crashing_task_,
                                &addr,
                                &size,
                                &nesting_level,
-                               (vm_region_recurse_info_t)&info,
+                               recurse_info,
                                &info_count);
       if (ret == KERN_SUCCESS && ip >= addr && ip < (addr + size)) {
         // Try to get 128 bytes before and after the IP, but
@@ -806,7 +927,8 @@ bool MinidumpGenerator::WriteMemoryListStream(
           std::min(uintptr_t(ip + (kIPMemorySize / 2)),
                    uintptr_t(addr + size));
         ip_memory_d.memory.data_size =
-          end_of_range - ip_memory_d.start_of_memory_range;
+            end_of_range -
+            static_cast<uintptr_t>(ip_memory_d.start_of_memory_range);
         have_ip_memory = true;
         // This needs to get appended to the list even though
         // the memory bytes aren't filled in yet so the entire
@@ -919,10 +1041,18 @@ bool MinidumpGenerator::WriteSystemInfoStream(
   MDRawSystemInfo *info_ptr = info.get();
 
   switch (cpu_type_) {
+#ifdef HAS_ARM_SUPPORT
+    case CPU_TYPE_ARM:
+      info_ptr->processor_architecture = MD_CPU_ARCHITECTURE_ARM;
+      break;
+#endif
+#ifdef HAS_PPC_SUPPORT
     case CPU_TYPE_POWERPC:
     case CPU_TYPE_POWERPC64:
       info_ptr->processor_architecture = MD_CPU_ARCHITECTURE_PPC;
       break;
+#endif
+#ifdef HAS_X86_SUPPORT
     case CPU_TYPE_I386:
     case CPU_TYPE_X86_64:
       if (cpu_type_ == CPU_TYPE_I386)
@@ -986,13 +1116,18 @@ bool MinidumpGenerator::WriteSystemInfoStream(
 
 #endif  // __i386__ || __x86_64_
       break;
+#endif  // HAS_X86_SUPPORT
     default:
       info_ptr->processor_architecture = MD_CPU_ARCHITECTURE_UNKNOWN;
       break;
   }
 
-  info_ptr->number_of_processors = number_of_processors;
+  info_ptr->number_of_processors = static_cast<uint8_t>(number_of_processors);
+#if TARGET_OS_IPHONE
+  info_ptr->platform_id = MD_OS_IOS;
+#else
   info_ptr->platform_id = MD_OS_MAC_OS_X;
+#endif  // TARGET_OS_IPHONE
 
   MDLocationDescriptor build_string_loc;
 
@@ -1032,7 +1167,7 @@ bool MinidumpGenerator::WriteModuleStream(unsigned int index,
     // We'll skip the executable module, because they don't have
     // LC_ID_DYLIB load commands, and the crash processing server gets
     // version information from the Plist file, anyway.
-    if (index != (uint32_t)FindExecutableModule()) {
+    if (index != static_cast<uint32_t>(FindExecutableModule())) {
       module->version_info.signature = MD_VSFIXEDFILEINFO_SIGNATURE;
       module->version_info.struct_version |= MD_VSFIXEDFILEINFO_VERSION;
       // Convert MAC dylib version format, which is a 32 bit number, to the
@@ -1049,7 +1184,7 @@ bool MinidumpGenerator::WriteModuleStream(unsigned int index,
       module->version_info.file_version_lo |= (modVersion & 0xff);
     }
 
-    if (!WriteCVRecord(module, image->GetCPUType(), name.c_str())) {
+    if (!WriteCVRecord(module, image->GetCPUType(), name.c_str(), false)) {
       return false;
     }
   } else {
@@ -1095,7 +1230,11 @@ bool MinidumpGenerator::WriteModuleStream(unsigned int index,
           module->size_of_image = static_cast<u_int32_t>(seg->vmsize);
           module->module_name_rva = string_location.rva;
 
-          if (!WriteCVRecord(module, cpu_type, name))
+          bool in_memory = false;
+#if TARGET_OS_IPHONE
+          in_memory = true;
+#endif
+          if (!WriteCVRecord(module, cpu_type, name, in_memory))
             return false;
 
           return true;
@@ -1133,7 +1272,7 @@ int MinidumpGenerator::FindExecutableModule() {
 }
 
 bool MinidumpGenerator::WriteCVRecord(MDRawModule *module, int cpu_type,
-                                      const char *module_path) {
+                                      const char *module_path, bool in_memory) {
   TypedMDRVA<MDCVInfoPDB70> cv(&writer_);
 
   // Only return the last path component of the full module path
@@ -1159,15 +1298,32 @@ bool MinidumpGenerator::WriteCVRecord(MDRawModule *module, int cpu_type,
   cv_ptr->age = 0;
 
   // Get the module identifier
-  FileID file_id(module_path);
   unsigned char identifier[16];
+  bool result = false;
+  if (in_memory) {
+    MacFileUtilities::MachoID macho(module_path,
+        reinterpret_cast<void *>(module->base_of_image),
+        static_cast<size_t>(module->size_of_image));
+    result = macho.UUIDCommand(cpu_type, identifier);
+    if (!result)
+      result = macho.MD5(cpu_type, identifier);
+  }
 
-  if (file_id.MachoIdentifier(cpu_type, identifier)) {
-    cv_ptr->signature.data1 = (uint32_t)identifier[0] << 24 |
-      (uint32_t)identifier[1] << 16 | (uint32_t)identifier[2] << 8 |
-      (uint32_t)identifier[3];
-    cv_ptr->signature.data2 = (uint32_t)identifier[4] << 8 | identifier[5];
-    cv_ptr->signature.data3 = (uint32_t)identifier[6] << 8 | identifier[7];
+  if (!result) {
+     FileID file_id(module_path);
+     result = file_id.MachoIdentifier(cpu_type, identifier);
+  }
+
+  if (result) {
+    cv_ptr->signature.data1 =
+        static_cast<uint32_t>(identifier[0]) << 24 |
+        static_cast<uint32_t>(identifier[1]) << 16 |
+        static_cast<uint32_t>(identifier[2]) << 8 |
+        static_cast<uint32_t>(identifier[3]);
+    cv_ptr->signature.data2 =
+        static_cast<uint16_t>(identifier[4] << 8) | identifier[5];
+    cv_ptr->signature.data3 =
+        static_cast<uint16_t>(identifier[6] << 8) | identifier[7];
     cv_ptr->signature.data4[0] = identifier[8];
     cv_ptr->signature.data4[1] = identifier[9];
     cv_ptr->signature.data4[2] = identifier[10];
@@ -1185,8 +1341,9 @@ bool MinidumpGenerator::WriteModuleListStream(
     MDRawDirectory *module_list_stream) {
   TypedMDRVA<MDRawModuleList> list(&writer_);
 
-  int image_count = dynamic_images_ ?
-    dynamic_images_->GetImageCount() : _dyld_image_count();
+  size_t image_count = dynamic_images_ ?
+      static_cast<size_t>(dynamic_images_->GetImageCount()) :
+      _dyld_image_count();
 
   if (!list.AllocateObjectAndArray(image_count, MD_MODULE_SIZE))
     return false;
@@ -1197,7 +1354,7 @@ bool MinidumpGenerator::WriteModuleListStream(
 
   // Write out the executable module as the first one
   MDRawModule module;
-  int executableIndex = FindExecutableModule();
+  size_t executableIndex = FindExecutableModule();
 
   if (!WriteModuleStream(executableIndex, &module)) {
     return false;
@@ -1206,7 +1363,7 @@ bool MinidumpGenerator::WriteModuleListStream(
   list.CopyIndexAfterObject(0, &module, MD_MODULE_SIZE);
   int destinationIndex = 1;  // Write all other modules after this one
 
-  for (int i = 0; i < image_count; ++i) {
+  for (size_t i = 0; i < image_count; ++i) {
     if (i != executableIndex) {
       if (!WriteModuleStream(i, &module)) {
         return false;
@@ -1246,21 +1403,14 @@ bool MinidumpGenerator::WriteMiscInfoStream(MDRawDirectory *misc_info_stream) {
     info_ptr->process_kernel_time =
         static_cast<u_int32_t>(usage.ru_stime.tv_sec);
   }
-  int mib[4] = { CTL_KERN, KERN_PROC, KERN_PROC_PID, static_cast<int>(info_ptr->process_id) };
+  int mib[4] = { CTL_KERN, KERN_PROC, KERN_PROC_PID,
+                 static_cast<int>(info_ptr->process_id) };
   u_int mibsize = static_cast<u_int>(sizeof(mib) / sizeof(mib[0]));
-  size_t size;
-  if (!sysctl(mib, mibsize, NULL, &size, NULL, 0)) {
-    mach_vm_address_t addr;
-    if (mach_vm_allocate(mach_task_self(),
-                         &addr,
-                         size,
-                         true) == KERN_SUCCESS) {
-      struct kinfo_proc *proc = (struct kinfo_proc *)addr;
-      if (!sysctl(mib, mibsize, proc, &size, NULL, 0))
-        info_ptr->process_create_time =
-            static_cast<u_int32_t>(proc->kp_proc.p_starttime.tv_sec);
-      mach_vm_deallocate(mach_task_self(), addr, size);
-    }
+  struct kinfo_proc proc;
+  size_t size = sizeof(proc);
+  if (sysctl(mib, mibsize, &proc, &size, NULL, 0) == 0) {
+    info_ptr->process_create_time =
+        static_cast<u_int32_t>(proc.kp_proc.p_starttime.tv_sec);
   }
 
   // Speed

toolkit/crashreporter/google-breakpad/src/client/mac/handler/minidump_generator.h

@@ -33,6 +33,7 @@
 #define CLIENT_MAC_GENERATOR_MINIDUMP_GENERATOR_H__
 
 #include <mach/mach.h>
+#include <TargetConditionals.h>
 
 #include <string>
 
@@ -42,21 +43,24 @@
 #include "google_breakpad/common/minidump_format.h"
 
 #include "dynamic_images.h"
+#include "mach_vm_compat.h"
 
-#if MAC_OS_X_VERSION_MAX_ALLOWED < MAC_OS_X_VERSION_10_7
+#if !TARGET_OS_IPHONE && (MAC_OS_X_VERSION_MAX_ALLOWED < MAC_OS_X_VERSION_10_7)
   #define HAS_PPC_SUPPORT
 #endif
+#if defined(__arm__)
+  #define HAS_ARM_SUPPORT
+#elif defined(__i386__) || defined(__x86_64__)
+  #define HAS_X86_SUPPORT
+#endif
 
 namespace google_breakpad {
 
 using std::string;
 
-const u_int64_t TOP_OF_THREAD0_STACK_64BIT = 0x00007fff5fbff000LL;
-const u_int32_t TOP_OF_THREAD0_STACK_32BIT = 0xbffff000;
-
 // Use the REGISTER_FROM_THREADSTATE to access a register name from the
 // breakpad_thread_state_t structure.
-#if __DARWIN_UNIX03 || TARGET_CPU_X86_64 || TARGET_CPU_PPC64
+#if __DARWIN_UNIX03 || TARGET_CPU_X86_64 || TARGET_CPU_PPC64 || TARGET_CPU_ARM
 // In The 10.5 SDK Headers Apple prepended __ to the variable names in the
 // i386_thread_state_t structure.  There's no good way to tell what version of
 // the SDK we're compiling against so we just toggle on the same preprocessor
@@ -78,7 +82,7 @@ class MinidumpGenerator {
   MinidumpGenerator();
   MinidumpGenerator(mach_port_t crashing_task, mach_port_t handler_thread);
 
-  ~MinidumpGenerator();
+  virtual ~MinidumpGenerator();
 
   // Return <dir>/<unique_name>.dmp
   // Sets |unique_name| (if requested) to the unique name for the minidump
@@ -98,17 +102,28 @@ class MinidumpGenerator {
     exception_thread_ = thread_name;
   }
 
+  // Specify the task context. If |task_context| is not NULL, it will be used
+  // to retrieve the context of the current thread, instead of using
+  // |thread_get_state|.
+  void SetTaskContext(ucontext_t *task_context);
+
   // Gather system information.  This should be call at least once before using
   // the MinidumpGenerator class.
   static void GatherSystemInformation();
 
+ protected:
+  // Overridable Stream writers
+  virtual bool WriteExceptionStream(MDRawDirectory *exception_stream);
+
+  // Overridable Helper
+  virtual bool WriteThreadStream(mach_port_t thread_id, MDRawThread *thread);
+
  private:
-    typedef bool (MinidumpGenerator::*WriteStreamFN)(MDRawDirectory *);
+  typedef bool (MinidumpGenerator::*WriteStreamFN)(MDRawDirectory *);
 
   // Stream writers
   bool WriteThreadListStream(MDRawDirectory *thread_list_stream);
   bool WriteMemoryListStream(MDRawDirectory *memory_list_stream);
-  bool WriteExceptionStream(MDRawDirectory *exception_stream);
   bool WriteSystemInfoStream(MDRawDirectory *system_info_stream);
   bool WriteModuleListStream(MDRawDirectory *module_list_stream);
   bool WriteMiscInfoStream(MDRawDirectory *misc_info_stream);
@@ -124,14 +139,20 @@ class MinidumpGenerator {
                   MDMemoryDescriptor *stack_location);
   bool WriteContext(breakpad_thread_state_data_t state,
                     MDLocationDescriptor *register_location);
-  bool WriteThreadStream(mach_port_t thread_id, MDRawThread *thread);
-  bool WriteCVRecord(MDRawModule *module, int cpu_type, 
-                     const char *module_path);
+  bool WriteCVRecord(MDRawModule *module, int cpu_type,
+                     const char *module_path, bool in_memory);
   bool WriteModuleStream(unsigned int index, MDRawModule *module);
   size_t CalculateStackSize(mach_vm_address_t start_addr);
   int  FindExecutableModule();
 
   // Per-CPU implementations of these methods
+#ifdef HAS_ARM_SUPPORT
+  bool WriteStackARM(breakpad_thread_state_data_t state,
+                     MDMemoryDescriptor *stack_location);
+  bool WriteContextARM(breakpad_thread_state_data_t state,
+                       MDLocationDescriptor *register_location);
+  u_int64_t CurrentPCForStackARM(breakpad_thread_state_data_t state);
+#endif
 #ifdef HAS_PPC_SUPPORT
   bool WriteStackPPC(breakpad_thread_state_data_t state,
                      MDMemoryDescriptor *stack_location);
@@ -144,6 +165,7 @@ class MinidumpGenerator {
                        MDLocationDescriptor *register_location);
   u_int64_t CurrentPCForStackPPC64(breakpad_thread_state_data_t state);
 #endif
+#ifdef HAS_X86_SUPPORT
   bool WriteStackX86(breakpad_thread_state_data_t state,
                        MDMemoryDescriptor *stack_location);
   bool WriteContextX86(breakpad_thread_state_data_t state,
@@ -154,14 +176,17 @@ class MinidumpGenerator {
   bool WriteContextX86_64(breakpad_thread_state_data_t state,
                           MDLocationDescriptor *register_location);
   u_int64_t CurrentPCForStackX86_64(breakpad_thread_state_data_t state);
+#endif
 
   // disallow copy ctor and operator=
   explicit MinidumpGenerator(const MinidumpGenerator &);
   void operator=(const MinidumpGenerator &);
 
+ protected:
   // Use this writer to put the data to disk
   MinidumpFileWriter writer_;
 
+ private:
   // Exception information
   int exception_type_;
   int exception_code_;
@@ -178,7 +203,10 @@ class MinidumpGenerator {
   static int os_major_version_;
   static int os_minor_version_;
   static int os_build_number_;
-  
+
+  // Context of the task to dump.
+  ucontext_t *task_context_;
+
   // Information about dynamically loaded code
   DynamicImages *dynamic_images_;
 
@@ -186,6 +214,7 @@ class MinidumpGenerator {
   // directly from the system, even while handling an exception.
   mutable PageAllocator allocator_;
 
+ protected:
   // Blocks of memory written to the dump. These are all currently
   // written while writing the thread list stream, but saved here
   // so a memory list stream can be written afterwards.

toolkit/crashreporter/google-breakpad/src/client/mac/handler/minidump_test.xcodeproj/project.pbxproj

@@ -451,7 +451,14 @@
 			isa = PBXProject;
 			buildConfigurationList = 1DEB923508733DC60010E9CD /* Build configuration list for PBXProject "minidump_test" */;
 			compatibilityVersion = "Xcode 3.2";
+			developmentRegion = English;
 			hasScannedForEncodings = 1;
+			knownRegions = (
+				English,
+				Japanese,
+				French,
+				German,
+			);
 			mainGroup = 08FB7794FE84155DC02AAC07 /* MinidumpWriter */;
 			projectDirPath = "";
 			projectRoot = "";

toolkit/crashreporter/google-breakpad/src/client/mac/handler/testcases/DynamicImagesTests.cc

@@ -55,21 +55,17 @@ void DynamicImagesTests::ReadTaskMemoryTest() {
   // pick test2 as a symbol we know to be valid to read
   // anything will work, really
   void *addr = reinterpret_cast<void*>(&test2);
-  void *buf;
+  std::vector<uint8_t> buf(getpagesize());
 
   fprintf(stderr, "reading 0x%p\n", addr);
-  buf = google_breakpad::ReadTaskMemory(mach_task_self(),
-                                        addr,
-                                        getpagesize(),
-                                        &kr);
+  kr = google_breakpad::ReadTaskMemory(mach_task_self(),
+                                       (uint64_t)addr,
+                                       getpagesize(),
+                                       buf);
 
   CPTAssert(kr == KERN_SUCCESS);
 
-  CPTAssert(buf != NULL);
-
-  CPTAssert(0 == memcmp(buf, (const void*)addr, getpagesize()));
-
-  free(buf);
+  CPTAssert(0 == memcmp(&buf[0], (const void*)addr, getpagesize()));
 }
 
 void DynamicImagesTests::ReadLibrariesFromLocalTaskTest() {
@@ -79,7 +75,5 @@ void DynamicImagesTests::ReadLibrariesFromLocalTaskTest() {
 
   fprintf(stderr,"Local task image count: %d\n", d->GetImageCount());
 
-  d->TestPrint();
-
   CPTAssert(d->GetImageCount() > 0);
 }

toolkit/crashreporter/google-breakpad/src/client/mac/sender/crash_report_sender.h

@@ -32,17 +32,11 @@
 // It will perform throttling based on the parameters passed to it and will
 // prompt the user to send the minidump.
 
-#include <Foundation/Foundation.h>
+#import <Cocoa/Cocoa.h>
 
-#include "client/mac/Framework/Breakpad.h"
+#include "client/mac/sender/uploader.h"
 #import "GTMDefines.h"
 
-#define kClientIdPreferenceKey @"clientid"
-
-extern NSString *const kGoogleServerType;
-extern NSString *const kSocorroServerType;
-extern NSString *const kDefaultServerType;
-
 // We're sublcassing NSTextField in order to override a particular
 // method (see the implementation) that lets us reject changes if they
 // are longer than a particular length.  Bindings would normally solve
@@ -87,29 +81,12 @@ extern NSString *const kDefaultServerType;
   NSString *countdownMessage_;             // Message indicating time
                                            // left for input.
  @private
-  int configFile_;                         // File descriptor for config file
-  NSMutableDictionary *parameters_;        // Key value pairs of data (STRONG)
-  NSData *minidumpContents_;               // The data in the minidump (STRONG)
-  NSData *logFileData_;                    // An NSdata for the tar,
-                                           // bz2'd log file.
   NSTimeInterval remainingDialogTime_;     // Keeps track of how long
                                            // we have until we cancel
                                            // the dialog
   NSTimer *messageTimer_;                  // Timer we use to update
                                            // the dialog
-  NSMutableDictionary *serverDictionary_;  // The dictionary mapping a
-                                           // server type name to a
-                                           // dictionary of server
-                                           // parameter names.
-  NSMutableDictionary *socorroDictionary_; // The dictionary for
-                                           // Socorro.
-  NSMutableDictionary *googleDictionary_;  // The dictionary for
-                                           // Google.
-  NSMutableDictionary *extraServerVars_;   // A dictionary containing
-                                           // extra key/value pairs
-                                           // that are uploaded to the
-                                           // crash server with the
-                                           // minidump.
+  Uploader* uploader_;                     // Uploader we use to send the data.
 }
 
 // Stops the modal panel with an NSAlertDefaultReturn value. This is the action

toolkit/crashreporter/google-breakpad/src/client/mac/sender/crash_report_sender.m

@@ -27,31 +27,26 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-#import <pwd.h>
-#import <sys/stat.h>
-#import <unistd.h>
+#import "client/mac/sender/crash_report_sender.h"
 
 #import <Cocoa/Cocoa.h>
+#import <pwd.h>
+#import <sys/stat.h>
 #import <SystemConfiguration/SystemConfiguration.h>
+#import <unistd.h>
 
-#import "common/mac/HTTPMultipartUpload.h"
-
-#import "crash_report_sender.h"
+#import "client/apple/Framework/BreakpadDefines.h"
 #import "common/mac/GTMLogger.h"
+#import "common/mac/HTTPMultipartUpload.h"
 
 
 #define kLastSubmission @"LastSubmission"
-const int kMinidumpFileLengthLimit = 800000;
 const int kUserCommentsMaxLength = 1500;
 const int kEmailMaxLength = 64;
 
 #define kApplePrefsSyncExcludeAllKey \
   @"com.apple.PreferenceSync.ExcludeAllSyncKeys"
 
-NSString *const kGoogleServerType = @"google";
-NSString *const kSocorroServerType = @"socorro";
-NSString *const kDefaultServerType = @"google";
-
 #pragma mark -
 
 @interface NSView (ResizabilityExtentions)
@@ -160,18 +155,8 @@ NSString *const kDefaultServerType = @"google";
 
 #pragma mark -
 
-
 @interface Reporter(PrivateMethods)
-+ (uid_t)consoleUID;
-
-- (id)initWithConfigurationFD:(int)fd;
-
-- (NSString *)readString;
-- (NSData *)readData:(ssize_t)length;
-
-- (BOOL)readConfigurationData;
-- (BOOL)readMinidumpData;
-- (BOOL)readLogFileData;
+- (id)initWithConfigFile:(const char *)configFile;
 
 // Returns YES if it has been long enough since the last report that we should
 // submit a report for this crash.
@@ -221,30 +206,6 @@ NSString *const kDefaultServerType = @"google";
 - (NSInteger)runModalWindow:(NSWindow*)window 
                 withTimeout:(NSTimeInterval)timeout;
 
-// Returns a unique client id (user-specific), creating a persistent
-// one in the user defaults, if necessary.
-- (NSString*)clientID;
-
-// Returns a dictionary that can be used to map Breakpad parameter names to
-// URL parameter names.
-- (NSMutableDictionary *)dictionaryForServerType:(NSString *)serverType;
-
-// Helper method to set HTTP parameters based on server type.  This is
-// called right before the upload - crashParameters will contain, on exit,
-// URL parameters that should be sent with the minidump.
-- (BOOL)populateServerDictionary:(NSMutableDictionary *)crashParameters;
-
-// Initialization helper to create dictionaries mapping Breakpad
-// parameters to URL parameters
-- (void)createServerParameterDictionaries;
-
-// Accessor method for the URL parameter dictionary
-- (NSMutableDictionary *)urlParameterDictionary;
-
-// This method adds a key/value pair to the dictionary that
-// will be uploaded to the crash server.
-- (void)addServerParameter:(id)value forKey:(NSString *)key;
-
 // This method is used to periodically update the UI with how many
 // seconds are left in the dialog display.
 - (void)updateSecondsLeftInDialogDisplay:(NSTimer*)theTimer;
@@ -255,288 +216,24 @@ NSString *const kDefaultServerType = @"google";
 // in their comments/email.
 - (void)controlTextDidBeginEditing:(NSNotification *)aNotification;
 
+- (void)report;
+
 @end
 
 @implementation Reporter
 //=============================================================================
-+ (uid_t)consoleUID {
-  SCDynamicStoreRef store =
-    SCDynamicStoreCreate(kCFAllocatorDefault, CFSTR("Reporter"), NULL, NULL);
-  uid_t uid = -2;  // Default to "nobody"
-  if (store) {
-    CFStringRef user = SCDynamicStoreCopyConsoleUser(store, &uid, NULL);
-
-    if (user)
-      CFRelease(user);
-    else
-      uid = -2;
-
-    CFRelease(store);
-  }
-
-  return uid;
-}
-
-//=============================================================================
-- (id)initWithConfigurationFD:(int)fd {
+- (id)initWithConfigFile:(const char *)configFile {
   if ((self = [super init])) {
-    configFile_ = fd;
     remainingDialogTime_ = 0;
+    uploader_ = [[Uploader alloc] initWithConfigFile:configFile];
+    if (!uploader_) {
+      [self release];
+      return nil;
+    }
   }
-
-  // Because the reporter is embedded in the framework (and many copies
-  // of the framework may exist) its not completely certain that the OS
-  // will obey the com.apple.PreferenceSync.ExcludeAllSyncKeys in our
-  // Info.plist. To make sure, also set the key directly if needed.
-  NSUserDefaults *ud = [NSUserDefaults standardUserDefaults];
-  if (![ud boolForKey:kApplePrefsSyncExcludeAllKey]) {
-    [ud setBool:YES forKey:kApplePrefsSyncExcludeAllKey];
-  }
-
-  [self createServerParameterDictionaries];
-
   return self;
 }
 
-//=============================================================================
-- (NSString *)readString {
-  NSMutableString *str = [NSMutableString stringWithCapacity:32];
-  char ch[2] = { 0 };
-
-  while (read(configFile_, &ch[0], 1) == 1) {
-    if (ch[0] == '\n') {
-      // Break if this is the first newline after reading some other string
-      // data.
-      if ([str length])
-        break;
-    } else {
-      [str appendString:[NSString stringWithUTF8String:ch]];
-    }
-  }
-
-  return str;
-}
-
-//=============================================================================
-- (NSData *)readData:(ssize_t)length {
-  NSMutableData *data = [NSMutableData dataWithLength:length];
-  char *bytes = (char *)[data bytes];
-
-  if (read(configFile_, bytes, length) != length)
-    return nil;
-
-  return data;
-}
-
-//=============================================================================
-- (BOOL)readConfigurationData {
-  parameters_ = [[NSMutableDictionary alloc] init];
-
-  while (1) {
-    NSString *key = [self readString];
-
-    if (![key length])
-      break;
-
-    // Read the data.  Try to convert to a UTF-8 string, or just save
-    // the data
-    NSString *lenStr = [self readString];
-    ssize_t len = [lenStr intValue];
-    NSData *data = [self readData:len];
-    id value = [[NSString alloc] initWithData:data
-                                     encoding:NSUTF8StringEncoding];
-
-    // If the keyname is prefixed by BREAKPAD_SERVER_PARAMETER_PREFIX
-    // that indicates that it should be uploaded to the server along
-    // with the minidump, so we treat it specially.
-    if ([key hasPrefix:@BREAKPAD_SERVER_PARAMETER_PREFIX]) {
-      NSString *urlParameterKey =
-        [key substringFromIndex:[@BREAKPAD_SERVER_PARAMETER_PREFIX length]];
-      if ([urlParameterKey length]) {
-        if (value) {
-          [self addServerParameter:value
-                            forKey:urlParameterKey];
-        } else {
-          [self addServerParameter:data
-                            forKey:urlParameterKey];
-        }
-      }
-    } else {
-      [parameters_ setObject:(value ? value : data) forKey:key];
-    }
-    [value release];
-  }
-
-  // generate a unique client ID based on this host's MAC address
-  // then add a key/value pair for it
-  NSString *clientID = [self clientID];
-  [parameters_ setObject:clientID forKey:@"guid"];
-
-  close(configFile_);
-  configFile_ = -1;
-
-  return YES;
-}
-
-// Per user per machine
-- (NSString *)clientID {
-  NSUserDefaults *ud = [NSUserDefaults standardUserDefaults];
-  NSString *crashClientID = [ud stringForKey:kClientIdPreferenceKey];
-  if (crashClientID) {
-    return crashClientID;
-  }
-
-  // Otherwise, if we have no client id, generate one!
-  srandom((int)[[NSDate date] timeIntervalSince1970]);
-  long clientId1 = random();
-  long clientId2 = random();
-  long clientId3 = random();
-  crashClientID = [NSString stringWithFormat:@"%x%x%x",
-                            clientId1, clientId2, clientId3];
-
-  [ud setObject:crashClientID forKey:kClientIdPreferenceKey];
-  [ud synchronize];
-  return crashClientID;
-}
-
-//=============================================================================
-- (BOOL)readLogFileData {
-  unsigned int logFileCounter = 0;
-
-  NSString *logPath;
-  size_t logFileTailSize =
-      [[parameters_ objectForKey:@BREAKPAD_LOGFILE_UPLOAD_SIZE] intValue];
-
-  NSMutableArray *logFilenames; // An array of NSString, one per log file
-  logFilenames = [[NSMutableArray alloc] init];
-
-  char tmpDirTemplate[80] = "/tmp/CrashUpload-XXXXX";
-  char *tmpDir = mkdtemp(tmpDirTemplate);
-
-  // Construct key names for the keys we expect to contain log file paths
-  for(logFileCounter = 0;; logFileCounter++) {
-    NSString *logFileKey = [NSString stringWithFormat:@"%@%d",
-                                     @BREAKPAD_LOGFILE_KEY_PREFIX,
-                                     logFileCounter];
-
-    logPath = [parameters_ objectForKey:logFileKey];
-
-    // They should all be consecutive, so if we don't find one, assume
-    // we're done
-
-    if (!logPath) {
-      break;
-    }
-
-    NSData *entireLogFile = [[NSData alloc] initWithContentsOfFile:logPath];
-
-    if (entireLogFile == nil) {
-      continue;
-    }
-
-    NSRange fileRange;
-
-    // Truncate the log file, only if necessary
-
-    if ([entireLogFile length] <= logFileTailSize) {
-      fileRange = NSMakeRange(0, [entireLogFile length]);
-    } else {
-      fileRange = NSMakeRange([entireLogFile length] - logFileTailSize,
-                              logFileTailSize);
-    }
-
-    char tmpFilenameTemplate[100];
-
-    // Generate a template based on the log filename
-    sprintf(tmpFilenameTemplate,"%s/%s-XXXX", tmpDir,
-            [[logPath lastPathComponent] fileSystemRepresentation]);
-
-    char *tmpFile = mktemp(tmpFilenameTemplate);
-
-    NSData *logSubdata = [entireLogFile subdataWithRange:fileRange];
-    NSString *tmpFileString = [NSString stringWithUTF8String:tmpFile];
-    [logSubdata writeToFile:tmpFileString atomically:NO];
-
-    [logFilenames addObject:[tmpFileString lastPathComponent]];
-    [entireLogFile release];
-  }
-
-  if ([logFilenames count] == 0) {
-    [logFilenames release];
-    logFileData_ =  nil;
-    return NO;
-  }
-
-  // now, bzip all files into one
-  NSTask *tarTask = [[NSTask alloc] init];
-
-  [tarTask setCurrentDirectoryPath:[NSString stringWithUTF8String:tmpDir]];
-  [tarTask setLaunchPath:@"/usr/bin/tar"];
-
-  NSMutableArray *bzipArgs = [NSMutableArray arrayWithObjects:@"-cjvf",
-                                             @"log.tar.bz2",nil];
-  [bzipArgs addObjectsFromArray:logFilenames];
-
-  [logFilenames release];
-
-  [tarTask setArguments:bzipArgs];
-  [tarTask launch];
-  [tarTask waitUntilExit];
-  [tarTask release];
-
-  NSString *logTarFile = [NSString stringWithFormat:@"%s/log.tar.bz2",tmpDir];
-  logFileData_ = [[NSData alloc] initWithContentsOfFile:logTarFile];
-  if (logFileData_ == nil) {
-    GTMLoggerDebug(@"Cannot find temp tar log file: %@", logTarFile);
-    return NO;
-  }
-  return YES;
-
-}
-
-//=============================================================================
-- (BOOL)readMinidumpData {
-  NSString *minidumpDir = [parameters_ objectForKey:@kReporterMinidumpDirectoryKey];
-  NSString *minidumpID = [parameters_ objectForKey:@kReporterMinidumpIDKey];
-
-  if (![minidumpID length])
-    return NO;
-
-  NSString *path = [minidumpDir stringByAppendingPathComponent:minidumpID];
-  path = [path stringByAppendingPathExtension:@"dmp"];
-
-  // check the size of the minidump and limit it to a reasonable size
-  // before attempting to load into memory and upload
-  const char *fileName = [path fileSystemRepresentation];
-  struct stat fileStatus;
-
-  BOOL success = YES;
-
-  if (!stat(fileName, &fileStatus)) {
-    if (fileStatus.st_size > kMinidumpFileLengthLimit) {
-      fprintf(stderr, "Breakpad Reporter: minidump file too large " \
-              "to upload : %d\n", (int)fileStatus.st_size);
-      success = NO;
-    }
-  } else {
-      fprintf(stderr, "Breakpad Reporter: unable to determine minidump " \
-              "file length\n");
-      success = NO;
-  }
-
-  if (success) {
-    minidumpContents_ = [[NSData alloc] initWithContentsOfFile:path];
-    success = ([minidumpContents_ length] ? YES : NO);
-  }
-
-  if (!success) {
-    // something wrong with the minidump file -- delete it
-    unlink(fileName);
-  }
-
-  return success;
-}
-
 //=============================================================================
 - (BOOL)askUserPermissionToSend {
   // Initialize Cocoa, needed to display the alert
@@ -557,12 +254,14 @@ NSString *const kDefaultServerType = @"google";
 
     buttonPressed = [self runModalWindow:alertWindow_ withTimeout:timeout];
 
-    // Extract info from the user into the parameters_ dictionary
+    // Extract info from the user into the uploader_.
     if ([self commentsValue]) {
-      [parameters_ setObject:[self commentsValue] forKey:@BREAKPAD_COMMENTS];
+      [[uploader_ parameters] setObject:[self commentsValue]
+                                 forKey:@BREAKPAD_COMMENTS];
     }
     if ([self emailValue]) {
-      [parameters_ setObject:[self emailValue] forKey:@BREAKPAD_EMAIL];
+      [[uploader_ parameters] setObject:[self emailValue]
+                                 forKey:@BREAKPAD_EMAIL];
     }
   } else {
     // Create an alert panel to tell the user something happened
@@ -613,17 +312,30 @@ NSString *const kDefaultServerType = @"google";
   CGFloat emailLabelWidthDelta = [emailLabel_ breakpad_adjustWidthToFit];
   [emailEntryField_ breakpad_shiftHorizontally:emailLabelWidthDelta];
 
+  // Localize the privacy policy label, and keep it right-aligned to the arrow.
+  [privacyLinkLabel_ setStringValue:NSLocalizedString(@"privacyLabel", @"")];
+  CGFloat privacyLabelWidthDelta =
+      [privacyLinkLabel_ breakpad_adjustWidthToFit];
+  [privacyLinkLabel_ breakpad_shiftHorizontally:(-privacyLabelWidthDelta)];
+
+  // Ensure that the email field and the privacy policy link don't overlap.
+  CGFloat kMinControlPadding = 8;
+  CGFloat maxEmailFieldWidth = NSMinX([privacyLinkLabel_ frame]) -
+                               NSMinX([emailEntryField_ frame]) -
+                               kMinControlPadding;
+  if (NSWidth([emailEntryField_ bounds]) > maxEmailFieldWidth &&
+      maxEmailFieldWidth > 0) {
+    NSSize emailSize = [emailEntryField_ frame].size;
+    emailSize.width = maxEmailFieldWidth;
+    [emailEntryField_ setFrameSize:emailSize];
+  }
+
   // Localize the placeholder text.
   [[commentsEntryField_ cell]
       setPlaceholderString:NSLocalizedString(@"commentsPlaceholder", @"")];
   [[emailEntryField_ cell]
       setPlaceholderString:NSLocalizedString(@"emailPlaceholder", @"")];
 
-  // Localize the privacy policy label, and keep it right-aligned to the arrow.
-  [privacyLinkLabel_ setStringValue:NSLocalizedString(@"privacyLabel", @"")];
-  CGFloat privacyLabelWidthDelta = [privacyLinkLabel_ breakpad_adjustWidthToFit];
-  [privacyLinkLabel_ breakpad_shiftHorizontally:(-privacyLabelWidthDelta)];
-
   // Localize the buttons, and keep the cancel button at the right distance.
   [sendButton_ setTitle:NSLocalizedString(@"sendReportButton", @"")];
   CGFloat sendButtonWidthDelta = [sendButton_ breakpad_smartSizeToFit];
@@ -788,9 +500,9 @@ doCommandBySelector:(SEL)commandSelector {
 #pragma mark -
 //=============================================================================
 - (BOOL)reportIntervalElapsed {
-  float interval = [[parameters_ objectForKey:@BREAKPAD_REPORT_INTERVAL]
-    floatValue];
-  NSString *program = [parameters_ objectForKey:@BREAKPAD_PRODUCT];
+  float interval = [[[uploader_ parameters]
+      objectForKey:@BREAKPAD_REPORT_INTERVAL] floatValue];
+  NSString *program = [[uploader_ parameters] objectForKey:@BREAKPAD_PRODUCT];
   NSUserDefaults *ud = [NSUserDefaults standardUserDefaults];
   NSMutableDictionary *programDict =
     [NSMutableDictionary dictionaryWithDictionary:[ud dictionaryForKey:program]];
@@ -815,29 +527,30 @@ doCommandBySelector:(SEL)commandSelector {
 }
 
 - (BOOL)isOnDemand {
-  return [[parameters_ objectForKey:@BREAKPAD_ON_DEMAND]
+  return [[[uploader_ parameters] objectForKey:@BREAKPAD_ON_DEMAND]
 	   isEqualToString:@"YES"];
 }
 
 - (BOOL)shouldSubmitSilently {
-  return [[parameters_ objectForKey:@BREAKPAD_SKIP_CONFIRM]
+  return [[[uploader_ parameters] objectForKey:@BREAKPAD_SKIP_CONFIRM]
             isEqualToString:@"YES"];
 }
 
 - (BOOL)shouldRequestComments {
-  return [[parameters_ objectForKey:@BREAKPAD_REQUEST_COMMENTS]
+  return [[[uploader_ parameters] objectForKey:@BREAKPAD_REQUEST_COMMENTS]
             isEqualToString:@"YES"];
 }
 
 - (BOOL)shouldRequestEmail {
-  return [[parameters_ objectForKey:@BREAKPAD_REQUEST_EMAIL]
+  return [[[uploader_ parameters] objectForKey:@BREAKPAD_REQUEST_EMAIL]
             isEqualToString:@"YES"];
 }
 
 - (NSString*)shortDialogMessage {
-  NSString *displayName = [parameters_ objectForKey:@BREAKPAD_PRODUCT_DISPLAY];
+  NSString *displayName =
+      [[uploader_ parameters] objectForKey:@BREAKPAD_PRODUCT_DISPLAY];
   if (![displayName length])
-    displayName = [parameters_ objectForKey:@BREAKPAD_PRODUCT];
+    displayName = [[uploader_ parameters] objectForKey:@BREAKPAD_PRODUCT];
 
   if ([self isOnDemand]) {
     return [NSString
@@ -851,11 +564,12 @@ doCommandBySelector:(SEL)commandSelector {
 }
 
 - (NSString*)explanatoryDialogText {
-  NSString *displayName = [parameters_ objectForKey:@BREAKPAD_PRODUCT_DISPLAY];
+  NSString *displayName =
+      [[uploader_ parameters] objectForKey:@BREAKPAD_PRODUCT_DISPLAY];
   if (![displayName length])
-    displayName = [parameters_ objectForKey:@BREAKPAD_PRODUCT];
+    displayName = [[uploader_ parameters] objectForKey:@BREAKPAD_PRODUCT];
 
-  NSString *vendor = [parameters_ objectForKey:@BREAKPAD_VENDOR];
+  NSString *vendor = [[uploader_ parameters] objectForKey:@BREAKPAD_VENDOR];
   if (![vendor length])
     vendor = @"unknown vendor";
 
@@ -872,8 +586,8 @@ doCommandBySelector:(SEL)commandSelector {
 
 - (NSTimeInterval)messageTimeout {
   // Get the timeout value for the notification.
-  NSTimeInterval timeout = [[parameters_ objectForKey:@BREAKPAD_CONFIRM_TIMEOUT]
-                              floatValue];
+  NSTimeInterval timeout = [[[uploader_ parameters]
+      objectForKey:@BREAKPAD_CONFIRM_TIMEOUT] floatValue];
   // Require a timeout of at least a minute (except 0, which means no timeout).
   if (timeout > 0.001 && timeout < 60.0) {
     timeout = 60.0;
@@ -881,170 +595,13 @@ doCommandBySelector:(SEL)commandSelector {
   return timeout;
 }
 
-- (void)createServerParameterDictionaries {
-  serverDictionary_ = [[NSMutableDictionary alloc] init];
-  socorroDictionary_ = [[NSMutableDictionary alloc] init];
-  googleDictionary_ = [[NSMutableDictionary alloc] init];
-  extraServerVars_ = [[NSMutableDictionary alloc] init];
-
-  [serverDictionary_ setObject:socorroDictionary_ forKey:kSocorroServerType];
-  [serverDictionary_ setObject:googleDictionary_ forKey:kGoogleServerType];
-
-  [googleDictionary_ setObject:@"ptime" forKey:@BREAKPAD_PROCESS_UP_TIME];
-  [googleDictionary_ setObject:@"email" forKey:@BREAKPAD_EMAIL];
-  [googleDictionary_ setObject:@"comments" forKey:@BREAKPAD_COMMENTS];
-  [googleDictionary_ setObject:@"prod" forKey:@BREAKPAD_PRODUCT];
-  [googleDictionary_ setObject:@"ver" forKey:@BREAKPAD_VERSION];
-
-  [socorroDictionary_ setObject:@"Comments" forKey:@BREAKPAD_COMMENTS];
-  [socorroDictionary_ setObject:@"CrashTime"
-                         forKey:@BREAKPAD_PROCESS_CRASH_TIME];
-  [socorroDictionary_ setObject:@"StartupTime"
-                         forKey:@BREAKPAD_PROCESS_START_TIME];
-  [socorroDictionary_ setObject:@"Version"
-                         forKey:@BREAKPAD_VERSION];
-  [socorroDictionary_ setObject:@"ProductName"
-                         forKey:@BREAKPAD_PRODUCT];
-  [socorroDictionary_ setObject:@"Email"
-                         forKey:@BREAKPAD_EMAIL];
-}
-
-- (NSMutableDictionary *)dictionaryForServerType:(NSString *)serverType {
-  if (serverType == nil || [serverType length] == 0) {
-    return [serverDictionary_ objectForKey:kDefaultServerType];
-  }
-  return [serverDictionary_ objectForKey:serverType];
-}
-
-- (NSMutableDictionary *)urlParameterDictionary {
-  NSString *serverType = [parameters_ objectForKey:@BREAKPAD_SERVER_TYPE];
-  return [self dictionaryForServerType:serverType];
-
-}
-
-- (BOOL)populateServerDictionary:(NSMutableDictionary *)crashParameters {
-  NSDictionary *urlParameterNames = [self urlParameterDictionary];
-
-  id key;
-  NSEnumerator *enumerator = [parameters_ keyEnumerator];
-
-  while ((key = [enumerator nextObject])) {
-    // The key from parameters_ corresponds to a key in
-    // urlParameterNames.  The value in parameters_ gets stored in
-    // crashParameters with a key that is the value in
-    // urlParameterNames.
-
-    // For instance, if parameters_ has [PRODUCT_NAME => "FOOBAR"] and
-    // urlParameterNames has [PRODUCT_NAME => "pname"] the final HTTP
-    // URL parameter becomes [pname => "FOOBAR"].
-    NSString *breakpadParameterName = (NSString *)key;
-    NSString *urlParameter = [urlParameterNames
-                                   objectForKey:breakpadParameterName];
-    if (urlParameter) {
-      [crashParameters setObject:[parameters_ objectForKey:key]
-                          forKey:urlParameter];
-    }
-  }
-
-  // Now, add the parameters that were added by the application.
-  enumerator = [extraServerVars_ keyEnumerator];
-
-  while ((key = [enumerator nextObject])) {
-    NSString *urlParameterName = (NSString *)key;
-    NSString *urlParameterValue =
-      [extraServerVars_ objectForKey:urlParameterName];
-    [crashParameters setObject:urlParameterValue
-                        forKey:urlParameterName];
-  }
-  return YES;
-}
-
-- (void)addServerParameter:(id)value forKey:(NSString *)key {
-  [extraServerVars_ setObject:value forKey:key];
-}
-
-//=============================================================================
 - (void)report {
-  NSURL *url = [NSURL URLWithString:[parameters_ objectForKey:@BREAKPAD_URL]];
-  HTTPMultipartUpload *upload = [[HTTPMultipartUpload alloc] initWithURL:url];
-  NSMutableDictionary *uploadParameters = [NSMutableDictionary dictionary];
-
-  if (![self populateServerDictionary:uploadParameters]) {
-    return;
-  }
-
-  [upload setParameters:uploadParameters];
-
-  // Add minidump file
-  if (minidumpContents_) {
-    [upload addFileContents:minidumpContents_ name:@"upload_file_minidump"];
-
-    // Send it
-    NSError *error = nil;
-    NSData *data = [upload send:&error];
-    NSString *result = [[NSString alloc] initWithData:data
-                                         encoding:NSUTF8StringEncoding];
-    const char *reportID = "ERR";
-
-    if (error) {
-      fprintf(stderr, "Breakpad Reporter: Send Error: %s\n",
-              [[error description] UTF8String]);
-    } else {
-      NSCharacterSet *trimSet = [NSCharacterSet whitespaceAndNewlineCharacterSet];
-      reportID = [[result stringByTrimmingCharactersInSet:trimSet] UTF8String];
-    }
-
-    // rename the minidump file according to the id returned from the server
-    NSString *minidumpDir = [parameters_ objectForKey:@kReporterMinidumpDirectoryKey];
-    NSString *minidumpID = [parameters_ objectForKey:@kReporterMinidumpIDKey];
-
-    NSString *srcString = [NSString stringWithFormat:@"%@/%@.dmp",
-                                    minidumpDir, minidumpID];
-    NSString *destString = [NSString stringWithFormat:@"%@/%s.dmp",
-                                     minidumpDir, reportID];
-
-    const char *src = [srcString fileSystemRepresentation];
-    const char *dest = [destString fileSystemRepresentation];
-
-    if (rename(src, dest) == 0) {
-      GTMLoggerInfo(@"Breakpad Reporter: Renamed %s to %s after successful " \
-                    "upload",src, dest);
-    }
-    else {
-      // can't rename - don't worry - it's not important for users
-      GTMLoggerDebug(@"Breakpad Reporter: successful upload report ID = %s\n",
-                     reportID );
-    }
-    [result release];
-  }
-
-  if (logFileData_) {
-    HTTPMultipartUpload *logUpload = [[HTTPMultipartUpload alloc] initWithURL:url];
-
-    [uploadParameters setObject:@"log" forKey:@"type"];
-    [logUpload setParameters:uploadParameters];
-    [logUpload addFileContents:logFileData_ name:@"log"];
-
-    NSError *error = nil;
-    NSData *data = [logUpload send:&error];
-    NSString *result = [[NSString alloc] initWithData:data
-                                         encoding:NSUTF8StringEncoding];
-    [result release];
-    [logUpload release];
-  }
-
-  [upload release];
+  [uploader_ report];
 }
 
 //=============================================================================
 - (void)dealloc {
-  [parameters_ release];
-  [minidumpContents_ release];
-  [logFileData_ release];
-  [googleDictionary_ release];
-  [socorroDictionary_ release];
-  [serverDictionary_ release];
-  [extraServerVars_ release];
+  [uploader_ release];
   [super dealloc];
 }
 
@@ -1135,40 +692,12 @@ int main(int argc, const char *argv[]) {
     exit(1);
   }
 
-  // Open the file before (potentially) switching to console user
-  int configFile = open(argv[1], O_RDONLY, 0600);
-
-  if (configFile == -1) {
-    GTMLoggerDebug(@"Couldn't open config file %s - %s",
-                   argv[1],
-                   strerror(errno));
-  }
-
-  // we want to avoid a build-up of old config files even if they
-  // have been incorrectly written by the framework
-  unlink(argv[1]);
-
-  if (configFile == -1) {
-    GTMLoggerDebug(@"Couldn't unlink config file %s - %s",
-                   argv[1],
-                   strerror(errno));
+  Reporter *reporter = [[Reporter alloc] initWithConfigFile:argv[1]];
+  if (!reporter) {
+    GTMLoggerDebug(@"reporter initialization failed");
     exit(1);
   }
 
-  Reporter *reporter = [[Reporter alloc] initWithConfigurationFD:configFile];
-
-  // Gather the configuration data
-  if (![reporter readConfigurationData]) {
-    GTMLoggerDebug(@"reporter readConfigurationData failed");
-    exit(1);
-  }
-
-  // Read the minidump into memory before we (potentially) switch from the
-  // root user
-  [reporter readMinidumpData];
-
-  [reporter readLogFileData];
-
   // only submit a report if we have not recently crashed in the past
   BOOL shouldSubmitReport = [reporter reportIntervalElapsed];
   BOOL okayToSend = NO;

toolkit/crashreporter/google-breakpad/src/client/mac/sender/uploader.h

@@ -0,0 +1,81 @@
+// Copyright (c) 2011, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// This component uses the HTTPMultipartUpload of the breakpad project to send
+// the minidump and associated data to the crash reporting servers.
+// It will perform throttling based on the parameters passed to it and will
+// prompt the user to send the minidump.
+
+#include <Foundation/Foundation.h>
+
+#import "common/mac/GTMDefines.h"
+
+#define kClientIdPreferenceKey @"clientid"
+
+extern NSString *const kGoogleServerType;
+extern NSString *const kSocorroServerType;
+extern NSString *const kDefaultServerType;
+
+@interface Uploader : NSObject {
+ @private
+  NSMutableDictionary *parameters_;        // Key value pairs of data (STRONG)
+  NSData *minidumpContents_;               // The data in the minidump (STRONG)
+  NSData *logFileData_;                    // An NSdata for the tar,
+                                           // bz2'd log file.
+  NSMutableDictionary *serverDictionary_;  // The dictionary mapping a
+                                           // server type name to a
+                                           // dictionary of server
+                                           // parameter names.
+  NSMutableDictionary *socorroDictionary_; // The dictionary for
+                                           // Socorro.
+  NSMutableDictionary *googleDictionary_;  // The dictionary for
+                                           // Google.
+  NSMutableDictionary *extraServerVars_;   // A dictionary containing
+                                           // extra key/value pairs
+                                           // that are uploaded to the
+                                           // crash server with the
+                                           // minidump.
+}
+
+- (id)initWithConfigFile:(const char *)configFile;
+
+- (id)initWithConfig:(NSDictionary *)config;
+
+- (NSMutableDictionary *)parameters;
+
+- (void)report;
+
+// Upload the given data to the crash server.
+- (void)uploadData:(NSData *)data name:(NSString *)name;
+
+// This method adds a key/value pair to the dictionary that
+// will be uploaded to the crash server.
+- (void)addServerParameter:(id)value forKey:(NSString *)key;
+
+@end

toolkit/crashreporter/google-breakpad/src/client/mac/sender/uploader.mm

@@ -0,0 +1,618 @@
+// Copyright (c) 2011, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#import <fcntl.h>
+#import <sys/stat.h>
+#include <TargetConditionals.h>
+#import <unistd.h>
+
+#import <SystemConfiguration/SystemConfiguration.h>
+
+#import "common/mac/HTTPMultipartUpload.h"
+
+#import "client/apple/Framework/BreakpadDefines.h"
+#import "client/mac/sender/uploader.h"
+#import "common/mac/GTMLogger.h"
+
+const int kMinidumpFileLengthLimit = 2 * 1024 * 1024;  // 2MB
+
+#define kApplePrefsSyncExcludeAllKey \
+  @"com.apple.PreferenceSync.ExcludeAllSyncKeys"
+
+NSString *const kGoogleServerType = @"google";
+NSString *const kSocorroServerType = @"socorro";
+NSString *const kDefaultServerType = @"google";
+
+#pragma mark -
+
+namespace {
+// Read one line from the configuration file.
+NSString *readString(int fileId) {
+  NSMutableString *str = [NSMutableString stringWithCapacity:32];
+  char ch[2] = { 0 };
+
+  while (read(fileId, &ch[0], 1) == 1) {
+    if (ch[0] == '\n') {
+      // Break if this is the first newline after reading some other string
+      // data.
+      if ([str length])
+        break;
+    } else {
+      [str appendString:[NSString stringWithUTF8String:ch]];
+    }
+  }
+
+  return str;
+}
+
+//=============================================================================
+// Read |length| of binary data from the configuration file. This method will
+// returns |nil| in case of error.
+NSData *readData(int fileId, ssize_t length) {
+  NSMutableData *data = [NSMutableData dataWithLength:length];
+  char *bytes = (char *)[data bytes];
+
+  if (read(fileId, bytes, length) != length)
+    return nil;
+
+  return data;
+}
+
+//=============================================================================
+// Read the configuration from the config file.
+NSDictionary *readConfigurationData(const char *configFile) {
+  int fileId = open(configFile, O_RDONLY, 0600);
+  if (fileId == -1) {
+    GTMLoggerDebug(@"Couldn't open config file %s - %s",
+                   configFile,
+                   strerror(errno));
+  }
+
+  // we want to avoid a build-up of old config files even if they
+  // have been incorrectly written by the framework
+  if (unlink(configFile)) {
+    GTMLoggerDebug(@"Couldn't unlink config file %s - %s",
+                   configFile,
+                   strerror(errno));
+  }
+
+  if (fileId == -1) {
+    return nil;
+  }
+
+  NSMutableDictionary *config = [NSMutableDictionary dictionary];
+
+  while (1) {
+    NSString *key = readString(fileId);
+
+    if (![key length])
+      break;
+
+    // Read the data.  Try to convert to a UTF-8 string, or just save
+    // the data
+    NSString *lenStr = readString(fileId);
+    ssize_t len = [lenStr intValue];
+    NSData *data = readData(fileId, len);
+    id value = [[NSString alloc] initWithData:data
+                                     encoding:NSUTF8StringEncoding];
+
+    [config setObject:(value ? value : data) forKey:key];
+    [value release];
+  }
+
+  close(fileId);
+  return config;
+}
+}  // namespace
+
+#pragma mark -
+
+@interface Uploader(PrivateMethods)
+
+// Update |parameters_| as well as the server parameters using |config|.
+- (void)translateConfigurationData:(NSDictionary *)config;
+
+// Read the minidump referenced in |parameters_| and update |minidumpContents_|
+// with its content.
+- (BOOL)readMinidumpData;
+
+// Read the log files referenced in |parameters_| and update |logFileData_|
+// with their content.
+- (BOOL)readLogFileData;
+
+// Returns a unique client id (user-specific), creating a persistent
+// one in the user defaults, if necessary.
+- (NSString*)clientID;
+
+// Returns a dictionary that can be used to map Breakpad parameter names to
+// URL parameter names.
+- (NSMutableDictionary *)dictionaryForServerType:(NSString *)serverType;
+
+// Helper method to set HTTP parameters based on server type.  This is
+// called right before the upload - crashParameters will contain, on exit,
+// URL parameters that should be sent with the minidump.
+- (BOOL)populateServerDictionary:(NSMutableDictionary *)crashParameters;
+
+// Initialization helper to create dictionaries mapping Breakpad
+// parameters to URL parameters
+- (void)createServerParameterDictionaries;
+
+// Accessor method for the URL parameter dictionary
+- (NSMutableDictionary *)urlParameterDictionary;
+
+// Records the uploaded crash ID to the log file.
+- (void)logUploadWithID:(const char *)uploadID;
+@end
+
+@implementation Uploader
+
+//=============================================================================
+- (id)initWithConfigFile:(const char *)configFile {
+  NSDictionary *config = readConfigurationData(configFile);
+  if (!config)
+    return nil;
+
+  return [self initWithConfig:config];
+}
+
+//=============================================================================
+- (id)initWithConfig:(NSDictionary *)config {
+  if ((self = [super init])) {
+    // Because the reporter is embedded in the framework (and many copies
+    // of the framework may exist) its not completely certain that the OS
+    // will obey the com.apple.PreferenceSync.ExcludeAllSyncKeys in our
+    // Info.plist. To make sure, also set the key directly if needed.
+    NSUserDefaults *ud = [NSUserDefaults standardUserDefaults];
+    if (![ud boolForKey:kApplePrefsSyncExcludeAllKey]) {
+      [ud setBool:YES forKey:kApplePrefsSyncExcludeAllKey];
+    }
+
+    [self createServerParameterDictionaries];
+
+    [self translateConfigurationData:config];
+
+    // Read the minidump into memory.
+    [self readMinidumpData];
+    [self readLogFileData];
+  }
+  return self;
+}
+
+//=============================================================================
+- (void)translateConfigurationData:(NSDictionary *)config {
+  parameters_ = [[NSMutableDictionary alloc] init];
+
+  NSEnumerator *it = [config keyEnumerator];
+  while (NSString *key = [it nextObject]) {
+    // If the keyname is prefixed by BREAKPAD_SERVER_PARAMETER_PREFIX
+    // that indicates that it should be uploaded to the server along
+    // with the minidump, so we treat it specially.
+    if ([key hasPrefix:@BREAKPAD_SERVER_PARAMETER_PREFIX]) {
+      NSString *urlParameterKey =
+        [key substringFromIndex:[@BREAKPAD_SERVER_PARAMETER_PREFIX length]];
+      if ([urlParameterKey length]) {
+        id value = [config objectForKey:key];
+        if ([value isKindOfClass:[NSString class]]) {
+          [self addServerParameter:(NSString *)value
+                            forKey:urlParameterKey];
+        } else {
+          [self addServerParameter:(NSData *)value
+                            forKey:urlParameterKey];
+        }
+      }
+    } else {
+      [parameters_ setObject:[config objectForKey:key] forKey:key];
+    }
+  }
+
+  // generate a unique client ID based on this host's MAC address
+  // then add a key/value pair for it
+  NSString *clientID = [self clientID];
+  [parameters_ setObject:clientID forKey:@"guid"];
+}
+
+// Per user per machine
+- (NSString *)clientID {
+  NSUserDefaults *ud = [NSUserDefaults standardUserDefaults];
+  NSString *crashClientID = [ud stringForKey:kClientIdPreferenceKey];
+  if (crashClientID) {
+    return crashClientID;
+  }
+
+  // Otherwise, if we have no client id, generate one!
+  srandom((int)[[NSDate date] timeIntervalSince1970]);
+  long clientId1 = random();
+  long clientId2 = random();
+  long clientId3 = random();
+  crashClientID = [NSString stringWithFormat:@"%lx%lx%lx",
+                            clientId1, clientId2, clientId3];
+
+  [ud setObject:crashClientID forKey:kClientIdPreferenceKey];
+  [ud synchronize];
+  return crashClientID;
+}
+
+//=============================================================================
+- (BOOL)readLogFileData {
+#if TARGET_OS_IPHONE
+  return NO;
+#else
+  unsigned int logFileCounter = 0;
+
+  NSString *logPath;
+  size_t logFileTailSize =
+      [[parameters_ objectForKey:@BREAKPAD_LOGFILE_UPLOAD_SIZE] intValue];
+
+  NSMutableArray *logFilenames; // An array of NSString, one per log file
+  logFilenames = [[NSMutableArray alloc] init];
+
+  char tmpDirTemplate[80] = "/tmp/CrashUpload-XXXXX";
+  char *tmpDir = mkdtemp(tmpDirTemplate);
+
+  // Construct key names for the keys we expect to contain log file paths
+  for(logFileCounter = 0;; logFileCounter++) {
+    NSString *logFileKey = [NSString stringWithFormat:@"%@%d",
+                                     @BREAKPAD_LOGFILE_KEY_PREFIX,
+                                     logFileCounter];
+
+    logPath = [parameters_ objectForKey:logFileKey];
+
+    // They should all be consecutive, so if we don't find one, assume
+    // we're done
+
+    if (!logPath) {
+      break;
+    }
+
+    NSData *entireLogFile = [[NSData alloc] initWithContentsOfFile:logPath];
+
+    if (entireLogFile == nil) {
+      continue;
+    }
+
+    NSRange fileRange;
+
+    // Truncate the log file, only if necessary
+
+    if ([entireLogFile length] <= logFileTailSize) {
+      fileRange = NSMakeRange(0, [entireLogFile length]);
+    } else {
+      fileRange = NSMakeRange([entireLogFile length] - logFileTailSize,
+                              logFileTailSize);
+    }
+
+    char tmpFilenameTemplate[100];
+
+    // Generate a template based on the log filename
+    sprintf(tmpFilenameTemplate,"%s/%s-XXXX", tmpDir,
+            [[logPath lastPathComponent] fileSystemRepresentation]);
+
+    char *tmpFile = mktemp(tmpFilenameTemplate);
+
+    NSData *logSubdata = [entireLogFile subdataWithRange:fileRange];
+    NSString *tmpFileString = [NSString stringWithUTF8String:tmpFile];
+    [logSubdata writeToFile:tmpFileString atomically:NO];
+
+    [logFilenames addObject:[tmpFileString lastPathComponent]];
+    [entireLogFile release];
+  }
+
+  if ([logFilenames count] == 0) {
+    [logFilenames release];
+    logFileData_ =  nil;
+    return NO;
+  }
+
+  // now, bzip all files into one
+  NSTask *tarTask = [[NSTask alloc] init];
+
+  [tarTask setCurrentDirectoryPath:[NSString stringWithUTF8String:tmpDir]];
+  [tarTask setLaunchPath:@"/usr/bin/tar"];
+
+  NSMutableArray *bzipArgs = [NSMutableArray arrayWithObjects:@"-cjvf",
+                                             @"log.tar.bz2",nil];
+  [bzipArgs addObjectsFromArray:logFilenames];
+
+  [logFilenames release];
+
+  [tarTask setArguments:bzipArgs];
+  [tarTask launch];
+  [tarTask waitUntilExit];
+  [tarTask release];
+
+  NSString *logTarFile = [NSString stringWithFormat:@"%s/log.tar.bz2",tmpDir];
+  logFileData_ = [[NSData alloc] initWithContentsOfFile:logTarFile];
+  if (logFileData_ == nil) {
+    GTMLoggerDebug(@"Cannot find temp tar log file: %@", logTarFile);
+    return NO;
+  }
+  return YES;
+#endif  // TARGET_OS_IPHONE
+}
+
+//=============================================================================
+- (BOOL)readMinidumpData {
+  NSString *minidumpDir =
+      [parameters_ objectForKey:@kReporterMinidumpDirectoryKey];
+  NSString *minidumpID = [parameters_ objectForKey:@kReporterMinidumpIDKey];
+
+  if (![minidumpID length])
+    return NO;
+
+  NSString *path = [minidumpDir stringByAppendingPathComponent:minidumpID];
+  path = [path stringByAppendingPathExtension:@"dmp"];
+
+  // check the size of the minidump and limit it to a reasonable size
+  // before attempting to load into memory and upload
+  const char *fileName = [path fileSystemRepresentation];
+  struct stat fileStatus;
+
+  BOOL success = YES;
+
+  if (!stat(fileName, &fileStatus)) {
+    if (fileStatus.st_size > kMinidumpFileLengthLimit) {
+      fprintf(stderr, "Breakpad Uploader: minidump file too large " \
+              "to upload : %d\n", (int)fileStatus.st_size);
+      success = NO;
+    }
+  } else {
+      fprintf(stderr, "Breakpad Uploader: unable to determine minidump " \
+              "file length\n");
+      success = NO;
+  }
+
+  if (success) {
+    minidumpContents_ = [[NSData alloc] initWithContentsOfFile:path];
+    success = ([minidumpContents_ length] ? YES : NO);
+  }
+
+  if (!success) {
+    // something wrong with the minidump file -- delete it
+    unlink(fileName);
+  }
+
+  return success;
+}
+
+#pragma mark -
+//=============================================================================
+
+- (void)createServerParameterDictionaries {
+  serverDictionary_ = [[NSMutableDictionary alloc] init];
+  socorroDictionary_ = [[NSMutableDictionary alloc] init];
+  googleDictionary_ = [[NSMutableDictionary alloc] init];
+  extraServerVars_ = [[NSMutableDictionary alloc] init];
+
+  [serverDictionary_ setObject:socorroDictionary_ forKey:kSocorroServerType];
+  [serverDictionary_ setObject:googleDictionary_ forKey:kGoogleServerType];
+
+  [googleDictionary_ setObject:@"ptime" forKey:@BREAKPAD_PROCESS_UP_TIME];
+  [googleDictionary_ setObject:@"email" forKey:@BREAKPAD_EMAIL];
+  [googleDictionary_ setObject:@"comments" forKey:@BREAKPAD_COMMENTS];
+  [googleDictionary_ setObject:@"prod" forKey:@BREAKPAD_PRODUCT];
+  [googleDictionary_ setObject:@"ver" forKey:@BREAKPAD_VERSION];
+  [googleDictionary_ setObject:@"guid" forKey:@"guid"];
+
+  [socorroDictionary_ setObject:@"Comments" forKey:@BREAKPAD_COMMENTS];
+  [socorroDictionary_ setObject:@"CrashTime"
+                         forKey:@BREAKPAD_PROCESS_CRASH_TIME];
+  [socorroDictionary_ setObject:@"StartupTime"
+                         forKey:@BREAKPAD_PROCESS_START_TIME];
+  [socorroDictionary_ setObject:@"Version"
+                         forKey:@BREAKPAD_VERSION];
+  [socorroDictionary_ setObject:@"ProductName"
+                         forKey:@BREAKPAD_PRODUCT];
+  [socorroDictionary_ setObject:@"Email"
+                         forKey:@BREAKPAD_EMAIL];
+}
+
+- (NSMutableDictionary *)dictionaryForServerType:(NSString *)serverType {
+  if (serverType == nil || [serverType length] == 0) {
+    return [serverDictionary_ objectForKey:kDefaultServerType];
+  }
+  return [serverDictionary_ objectForKey:serverType];
+}
+
+- (NSMutableDictionary *)urlParameterDictionary {
+  NSString *serverType = [parameters_ objectForKey:@BREAKPAD_SERVER_TYPE];
+  return [self dictionaryForServerType:serverType];
+
+}
+
+- (BOOL)populateServerDictionary:(NSMutableDictionary *)crashParameters {
+  NSDictionary *urlParameterNames = [self urlParameterDictionary];
+
+  id key;
+  NSEnumerator *enumerator = [parameters_ keyEnumerator];
+
+  while ((key = [enumerator nextObject])) {
+    // The key from parameters_ corresponds to a key in
+    // urlParameterNames.  The value in parameters_ gets stored in
+    // crashParameters with a key that is the value in
+    // urlParameterNames.
+
+    // For instance, if parameters_ has [PRODUCT_NAME => "FOOBAR"] and
+    // urlParameterNames has [PRODUCT_NAME => "pname"] the final HTTP
+    // URL parameter becomes [pname => "FOOBAR"].
+    NSString *breakpadParameterName = (NSString *)key;
+    NSString *urlParameter = [urlParameterNames
+                                   objectForKey:breakpadParameterName];
+    if (urlParameter) {
+      [crashParameters setObject:[parameters_ objectForKey:key]
+                          forKey:urlParameter];
+    }
+  }
+
+  // Now, add the parameters that were added by the application.
+  enumerator = [extraServerVars_ keyEnumerator];
+
+  while ((key = [enumerator nextObject])) {
+    NSString *urlParameterName = (NSString *)key;
+    NSString *urlParameterValue =
+      [extraServerVars_ objectForKey:urlParameterName];
+    [crashParameters setObject:urlParameterValue
+                        forKey:urlParameterName];
+  }
+  return YES;
+}
+
+- (void)addServerParameter:(id)value forKey:(NSString *)key {
+  [extraServerVars_ setObject:value forKey:key];
+}
+
+//=============================================================================
+- (void)report {
+  NSURL *url = [NSURL URLWithString:[parameters_ objectForKey:@BREAKPAD_URL]];
+  HTTPMultipartUpload *upload = [[HTTPMultipartUpload alloc] initWithURL:url];
+  NSMutableDictionary *uploadParameters = [NSMutableDictionary dictionary];
+
+  if (![self populateServerDictionary:uploadParameters]) {
+    [upload release];
+    return;
+  }
+
+  [upload setParameters:uploadParameters];
+
+  // Add minidump file
+  if (minidumpContents_) {
+    [upload addFileContents:minidumpContents_ name:@"upload_file_minidump"];
+
+    // If there is a log file, upload it together with the minidump.
+    if (logFileData_) {
+      [upload addFileContents:logFileData_ name:@"log"];
+    }
+
+    // Send it
+    NSError *error = nil;
+    NSData *data = [upload send:&error];
+    NSString *result = [[NSString alloc] initWithData:data
+                                         encoding:NSUTF8StringEncoding];
+    const char *reportID = "ERR";
+
+    if (error) {
+      fprintf(stderr, "Breakpad Uploader: Send Error: %s\n",
+              [[error description] UTF8String]);
+    } else {
+      NSCharacterSet *trimSet =
+          [NSCharacterSet whitespaceAndNewlineCharacterSet];
+      reportID = [[result stringByTrimmingCharactersInSet:trimSet] UTF8String];
+      [self logUploadWithID:reportID];
+    }
+
+    // rename the minidump file according to the id returned from the server
+    NSString *minidumpDir =
+        [parameters_ objectForKey:@kReporterMinidumpDirectoryKey];
+    NSString *minidumpID = [parameters_ objectForKey:@kReporterMinidumpIDKey];
+
+    NSString *srcString = [NSString stringWithFormat:@"%@/%@.dmp",
+                                    minidumpDir, minidumpID];
+    NSString *destString = [NSString stringWithFormat:@"%@/%s.dmp",
+                                     minidumpDir, reportID];
+
+    const char *src = [srcString fileSystemRepresentation];
+    const char *dest = [destString fileSystemRepresentation];
+
+    if (rename(src, dest) == 0) {
+      GTMLoggerInfo(@"Breakpad Uploader: Renamed %s to %s after successful " \
+                    "upload",src, dest);
+    }
+    else {
+      // can't rename - don't worry - it's not important for users
+      GTMLoggerDebug(@"Breakpad Uploader: successful upload report ID = %s\n",
+                     reportID );
+    }
+    [result release];
+  } else {
+    // Minidump is missing -- upload just the log file.
+    if (logFileData_) {
+      [self uploadData:logFileData_ name:@"log"];
+    }
+  }
+  [upload release];
+}
+
+- (void)uploadData:(NSData *)data name:(NSString *)name {
+  NSURL *url = [NSURL URLWithString:[parameters_ objectForKey:@BREAKPAD_URL]];
+  NSMutableDictionary *uploadParameters = [NSMutableDictionary dictionary];
+
+  if (![self populateServerDictionary:uploadParameters])
+    return;
+
+  HTTPMultipartUpload *upload =
+      [[HTTPMultipartUpload alloc] initWithURL:url];
+
+  [uploadParameters setObject:name forKey:@"type"];
+  [upload setParameters:uploadParameters];
+  [upload addFileContents:data name:name];
+
+  [upload send:nil];
+  [upload release];
+}
+
+- (void)logUploadWithID:(const char *)uploadID {
+  NSString *minidumpDir =
+      [parameters_ objectForKey:@kReporterMinidumpDirectoryKey];
+  NSString *logFilePath = [NSString stringWithFormat:@"%@/%s",
+      minidumpDir, kReporterLogFilename];
+  NSString *logLine = [NSString stringWithFormat:@"%0.f,%s\n",
+      [[NSDate date] timeIntervalSince1970], uploadID];
+  NSData *logData = [logLine dataUsingEncoding:NSUTF8StringEncoding];
+
+  NSFileManager *fileManager = [NSFileManager defaultManager];
+  if ([fileManager fileExistsAtPath:logFilePath]) {
+    NSFileHandle *logFileHandle =
+       [NSFileHandle fileHandleForWritingAtPath:logFilePath];
+    [logFileHandle seekToEndOfFile];
+    [logFileHandle writeData:logData];
+    [logFileHandle closeFile];
+  } else {
+    [fileManager createFileAtPath:logFilePath
+                         contents:logData
+                       attributes:nil];
+  }
+}
+
+//=============================================================================
+- (NSMutableDictionary *)parameters {
+  return parameters_;
+}
+
+//=============================================================================
+- (void)dealloc {
+  [parameters_ release];
+  [minidumpContents_ release];
+  [logFileData_ release];
+  [googleDictionary_ release];
+  [socorroDictionary_ release];
+  [serverDictionary_ release];
+  [extraServerVars_ release];
+  [super dealloc];
+}
+
+@end

toolkit/crashreporter/google-breakpad/src/client/mac/tests/crash_generation_server_test.cc

@@ -43,8 +43,8 @@
 #include "client/mac/crash_generation/crash_generation_client.h"
 #include "client/mac/crash_generation/crash_generation_server.h"
 #include "client/mac/handler/exception_handler.h"
-#include "client/mac/tests/auto_tempdir.h"
 #include "client/mac/tests/spawn_child_process.h"
+#include "common/tests/auto_tempdir.h"
 #include "google_breakpad/processor/minidump.h"
 
 namespace google_breakpad {
@@ -84,12 +84,14 @@ public:
   AutoTempDir temp_dir;
   // Counter just to ensure that we don't hit the same port again
   static int i;
+  bool filter_callback_called;
 
   void SetUp() {
     sprintf(mach_port_name,
-	    "com.google.breakpad.ServerTest.%d.%d", getpid(),
-	    CrashGenerationServerTest::i++);
+            "com.google.breakpad.ServerTest.%d.%d", getpid(),
+            CrashGenerationServerTest::i++);
     child_pid = (pid_t)-1;
+    filter_callback_called = false;
   }
 };
 int CrashGenerationServerTest::i = 0;
@@ -97,12 +99,14 @@ int CrashGenerationServerTest::i = 0;
 // Test that starting and stopping a server works
 TEST_F(CrashGenerationServerTest, testStartStopServer) {
   CrashGenerationServer server(mach_port_name,
-			       NULL,  // dump callback
-			       NULL,  // dump context
-			       NULL,  // exit callback
-			       NULL,  // exit context
-			       false, // generate dumps
-			       ""); // dump path
+                               NULL,  // filter callback
+                               NULL,  // filter context
+                               NULL,  // dump callback
+                               NULL,  // dump context
+                               NULL,  // exit callback
+                               NULL,  // exit context
+                               false, // generate dumps
+                               ""); // dump path
   ASSERT_TRUE(server.Start());
   ASSERT_TRUE(server.Stop());
 }
@@ -111,12 +115,14 @@ TEST_F(CrashGenerationServerTest, testStartStopServer) {
 // Test without actually dumping
 TEST_F(CrashGenerationServerTest, testRequestDumpNoDump) {
   CrashGenerationServer server(mach_port_name,
-			       NULL,  // dump callback
-			       NULL,  // dump context
-			       NULL,  // exit callback
-			       NULL,  // exit context
-			       false, // don't generate dumps
-			       temp_dir.path); // dump path
+                               NULL,  // filter callback
+                               NULL,  // filter context
+                               NULL,  // dump callback
+                               NULL,  // dump context
+                               NULL,  // exit callback
+                               NULL,  // exit context
+                               false, // don't generate dumps
+                               temp_dir.path()); // dump path
   ASSERT_TRUE(server.Start());
 
   pid_t pid = fork();
@@ -133,7 +139,7 @@ TEST_F(CrashGenerationServerTest, testRequestDumpNoDump) {
   EXPECT_EQ(0, WEXITSTATUS(ret));
   EXPECT_TRUE(server.Stop());
   // check that no minidump was written
-  string pattern = temp_dir.path + "/*";
+  string pattern = temp_dir.path() + "/*";
   glob_t dirContents;
   ret = glob(pattern.c_str(), GLOB_NOSORT, NULL, &dirContents);
   EXPECT_EQ(GLOB_NOMATCH, ret);
@@ -142,7 +148,7 @@ TEST_F(CrashGenerationServerTest, testRequestDumpNoDump) {
 }
 
 void dumpCallback(void *context, const ClientInfo &client_info,
-		  const std::string &file_path) {
+                  const std::string &file_path) {
   if (context) {
     CrashGenerationServerTest* self =
         reinterpret_cast<CrashGenerationServerTest*>(context);
@@ -161,12 +167,14 @@ void *RequestDump(void *context) {
 // Test that actually writing a minidump works
 TEST_F(CrashGenerationServerTest, testRequestDump) {
   CrashGenerationServer server(mach_port_name,
-			       dumpCallback,  // dump callback
-			       this,  // dump context
-			       NULL,  // exit callback
-			       NULL,  // exit context
-			       true, //  generate dumps
-			       temp_dir.path); // dump path
+                               NULL,  // filter callback
+                               NULL,  // filter context
+                               dumpCallback,  // dump callback
+                               this,  // dump context
+                               NULL,  // exit callback
+                               NULL,  // exit context
+                               true, //  generate dumps
+                               temp_dir.path()); // dump path
   ASSERT_TRUE(server.Start());
 
   pid_t pid = fork();
@@ -209,12 +217,14 @@ static void Crasher() {
 // the parent.
 TEST_F(CrashGenerationServerTest, testChildProcessCrash) {
   CrashGenerationServer server(mach_port_name,
-			       dumpCallback,  // dump callback
-			       this,  // dump context
-			       NULL,  // exit callback
-			       NULL,  // exit context
-			       true, //  generate dumps
-			       temp_dir.path); // dump path
+                               NULL,  // filter callback
+                               NULL,  // filter context
+                               dumpCallback,  // dump callback
+                               this,  // dump context
+                               NULL,  // exit callback
+                               NULL,  // exit context
+                               true, //  generate dumps
+                               temp_dir.path()); // dump path
   ASSERT_TRUE(server.Start());
 
   pid_t pid = fork();
@@ -270,12 +280,14 @@ TEST_F(CrashGenerationServerTest, testChildProcessCrash) {
 // produces a valid minidump.
 TEST_F(CrashGenerationServerTest, testChildProcessCrashCrossArchitecture) {
   CrashGenerationServer server(mach_port_name,
-			       dumpCallback,  // dump callback
-			       this,  // dump context
-			       NULL,  // exit callback
-			       NULL,  // exit context
-			       true, //  generate dumps
-			       temp_dir.path); // dump path
+                               NULL,  // filter callback
+                               NULL,  // filter context
+                               dumpCallback,  // dump callback
+                               this,  // dump context
+                               NULL,  // exit callback
+                               NULL,  // exit context
+                               true, //  generate dumps
+                               temp_dir.path()); // dump path
   ASSERT_TRUE(server.Start());
 
   // Spawn a child process
@@ -342,4 +354,45 @@ const u_int32_t kExpectedContext =
 }
 #endif
 
+bool filter_callback(void* context) {
+  CrashGenerationServerTest* self =
+    reinterpret_cast<CrashGenerationServerTest*>(context);
+  self->filter_callback_called = true;
+  // veto dump generation
+  return false;
+}
+
+// Test that a filter callback can veto minidump writing.
+TEST_F(CrashGenerationServerTest, testFilter) {
+  CrashGenerationServer server(mach_port_name,
+                               filter_callback,  // filter callback
+                               this,            // filter context
+                               dumpCallback,  // dump callback
+                               this,  // dump context
+                               NULL,  // exit callback
+                               NULL,  // exit context
+                               true, //  generate dumps
+                               temp_dir.path()); // dump path
+  ASSERT_TRUE(server.Start());
+
+  pid_t pid = fork();
+  ASSERT_NE(-1, pid);
+  if (pid == 0) {
+    // Instantiate an OOP exception handler.
+    ExceptionHandler eh("", NULL, NULL, NULL, true, mach_port_name);
+    Crasher();
+    // not reached
+    exit(0);
+  }
+
+  int ret;
+  ASSERT_EQ(pid, waitpid(pid, &ret, 0));
+  EXPECT_FALSE(WIFEXITED(ret));
+  EXPECT_TRUE(server.Stop());
+
+  // check that no minidump was written
+  EXPECT_TRUE(last_dump_name.empty());
+  EXPECT_TRUE(filter_callback_called);
+}
+
 }  // namespace

toolkit/crashreporter/google-breakpad/src/client/mac/tests/exception_handler_test.cc

@@ -29,14 +29,15 @@
 
 // exception_handler_test.cc: Unit tests for google_breakpad::ExceptionHandler
 
+#include <pthread.h>
 #include <sys/mman.h>
 #include <sys/stat.h>
 #include <unistd.h>
 
 #include "breakpad_googletest_includes.h"
 #include "client/mac/handler/exception_handler.h"
-#include "client/mac/tests/auto_tempdir.h"
 #include "common/mac/MachIPC.h"
+#include "common/tests/auto_tempdir.h"
 #include "google_breakpad/processor/minidump.h"
 
 namespace google_breakpad {
@@ -63,6 +64,7 @@ using testing::Test;
 
 class ExceptionHandlerTest : public Test {
  public:
+  void InProcessCrash(bool aborting);
   AutoTempDir tempDir;
   string lastDumpName;
 };
@@ -74,8 +76,13 @@ static void Crasher() {
   fprintf(stdout, "A = %d", *a);
 }
 
-static void SoonToCrash() {
-  Crasher();
+static void AbortCrasher() {
+  fprintf(stdout, "Going to crash...\n");
+  abort();
+}
+
+static void SoonToCrash(void(*crasher)()) {
+  crasher();
 }
 
 static bool MDCallback(const char *dump_dir, const char *file_name,
@@ -93,7 +100,7 @@ static bool MDCallback(const char *dump_dir, const char *file_name,
   return true;
 }
 
-TEST_F(ExceptionHandlerTest, InProcess) {
+void ExceptionHandlerTest::InProcessCrash(bool aborting) {
   // Give the child process a pipe to report back on.
   int fds[2];
   ASSERT_EQ(0, pipe(fds));
@@ -102,9 +109,9 @@ TEST_F(ExceptionHandlerTest, InProcess) {
   if (pid == 0) {
     // In the child process.
     close(fds[0]);
-    ExceptionHandler eh(tempDir.path, NULL, MDCallback, &fds[1], true, NULL);
+    ExceptionHandler eh(tempDir.path(), NULL, MDCallback, &fds[1], true, NULL);
     // crash
-    SoonToCrash();
+    SoonToCrash(aborting ? &AbortCrasher : &Crasher);
     // not reached
     exit(1);
   }
@@ -127,8 +134,18 @@ TEST_F(ExceptionHandlerTest, InProcess) {
   EXPECT_EQ(0, WEXITSTATUS(ret));
 }
 
-static bool ChildMDCallback(const char *dump_dir, const char *file_name,
-			    void *context, bool success) {
+TEST_F(ExceptionHandlerTest, InProcess) {
+  InProcessCrash(false);
+}
+
+#if TARGET_OS_IPHONE
+TEST_F(ExceptionHandlerTest, InProcessAbort) {
+  InProcessCrash(true);
+}
+#endif
+
+static bool DumpNameMDCallback(const char *dump_dir, const char *file_name,
+                               void *context, bool success) {
   ExceptionHandlerTest *self = reinterpret_cast<ExceptionHandlerTest*>(context);
   if (dump_dir && file_name) {
     self->lastDumpName = dump_dir;
@@ -139,6 +156,49 @@ static bool ChildMDCallback(const char *dump_dir, const char *file_name,
   return true;
 }
 
+TEST_F(ExceptionHandlerTest, WriteMinidump) {
+  ExceptionHandler eh(tempDir.path(), NULL, DumpNameMDCallback, this, true,
+                      NULL);
+  ASSERT_TRUE(eh.WriteMinidump());
+
+  // Ensure that minidump file exists and is > 0 bytes.
+  ASSERT_FALSE(lastDumpName.empty());
+  struct stat st;
+  ASSERT_EQ(0, stat(lastDumpName.c_str(), &st));
+  ASSERT_LT(0, st.st_size);
+
+  // The minidump should not contain an exception stream.
+  Minidump minidump(lastDumpName);
+  ASSERT_TRUE(minidump.Read());
+
+  MinidumpException* exception = minidump.GetException();
+  EXPECT_FALSE(exception);
+}
+
+TEST_F(ExceptionHandlerTest, WriteMinidumpWithException) {
+  ExceptionHandler eh(tempDir.path(), NULL, DumpNameMDCallback, this, true,
+                      NULL);
+  ASSERT_TRUE(eh.WriteMinidump(true));
+
+  // Ensure that minidump file exists and is > 0 bytes.
+  ASSERT_FALSE(lastDumpName.empty());
+  struct stat st;
+  ASSERT_EQ(0, stat(lastDumpName.c_str(), &st));
+  ASSERT_LT(0, st.st_size);
+
+  // The minidump should contain an exception stream.
+  Minidump minidump(lastDumpName);
+  ASSERT_TRUE(minidump.Read());
+
+  MinidumpException* exception = minidump.GetException();
+  ASSERT_TRUE(exception);
+  const MDRawExceptionStream* raw_exception = exception->exception();
+  ASSERT_TRUE(raw_exception);
+
+  EXPECT_EQ(MD_EXCEPTION_MAC_BREAKPOINT,
+            raw_exception->exception_record.exception_code);
+}
+
 TEST_F(ExceptionHandlerTest, DumpChildProcess) {
   const int kTimeoutMs = 2000;
   // Create a mach port to receive the child task on.
@@ -185,10 +245,10 @@ TEST_F(ExceptionHandlerTest, DumpChildProcess) {
 
   // Write a minidump of the child process.
   bool result = ExceptionHandler::WriteMinidumpForChild(child_task,
-							child_thread,
-							tempDir.path,
-							ChildMDCallback,
-							this);
+                                                        child_thread,
+                                                        tempDir.path(),
+                                                        DumpNameMDCallback,
+                                                        this);
   ASSERT_EQ(true, result);
 
   // Ensure that minidump file exists and is > 0 bytes.
@@ -225,7 +285,7 @@ TEST_F(ExceptionHandlerTest, InstructionPointerMemory) {
   pid_t pid = fork();
   if (pid == 0) {
     close(fds[0]);
-    ExceptionHandler eh(tempDir.path, NULL, MDCallback, &fds[1], true, NULL);
+    ExceptionHandler eh(tempDir.path(), NULL, MDCallback, &fds[1], true, NULL);
     // Get some executable memory.
     char* memory =
       reinterpret_cast<char*>(mmap(NULL,
@@ -241,7 +301,7 @@ TEST_F(ExceptionHandlerTest, InstructionPointerMemory) {
     // of the block of memory, because the minidump should contain 128
     // bytes on either side of the instruction pointer.
     memcpy(memory + kOffset, instructions, sizeof(instructions));
-    
+
     // Now execute the instructions, which should crash.
     typedef void (*void_function)(void);
     void_function memory_function =
@@ -287,20 +347,7 @@ TEST_F(ExceptionHandlerTest, InstructionPointerMemory) {
   ASSERT_TRUE(context);
 
   u_int64_t instruction_pointer;
-  switch (context->GetContextCPU()) {
-  case MD_CONTEXT_X86:
-    instruction_pointer = context->GetContextX86()->eip;
-    break;
-  case MD_CONTEXT_AMD64:
-    instruction_pointer = context->GetContextAMD64()->rip;
-    break;
-  case MD_CONTEXT_ARM:
-    instruction_pointer = context->GetContextARM()->iregs[15];
-    break;
-  default:
-    FAIL() << "Unknown context CPU: " << context->GetContextCPU();
-    break;
-  }
+  ASSERT_TRUE(context->GetInstructionPointer(&instruction_pointer));
 
   MinidumpMemoryRegion* region =
     memory_list->GetMemoryRegionForAddress(instruction_pointer);
@@ -337,7 +384,7 @@ TEST_F(ExceptionHandlerTest, InstructionPointerMemoryMinBound) {
   pid_t pid = fork();
   if (pid == 0) {
     close(fds[0]);
-    ExceptionHandler eh(tempDir.path, NULL, MDCallback, &fds[1], true, NULL);
+    ExceptionHandler eh(tempDir.path(), NULL, MDCallback, &fds[1], true, NULL);
     // Get some executable memory.
     char* memory =
       reinterpret_cast<char*>(mmap(NULL,
@@ -399,20 +446,7 @@ TEST_F(ExceptionHandlerTest, InstructionPointerMemoryMinBound) {
   ASSERT_TRUE(context);
 
   u_int64_t instruction_pointer;
-  switch (context->GetContextCPU()) {
-  case MD_CONTEXT_X86:
-    instruction_pointer = context->GetContextX86()->eip;
-    break;
-  case MD_CONTEXT_AMD64:
-    instruction_pointer = context->GetContextAMD64()->rip;
-    break;
-  case MD_CONTEXT_ARM:
-    instruction_pointer = context->GetContextARM()->iregs[15];
-    break;
-  default:
-    FAIL() << "Unknown context CPU: " << context->GetContextCPU();
-    break;
-  }
+  ASSERT_TRUE(context->GetInstructionPointer(&instruction_pointer));
 
   MinidumpMemoryRegion* region =
     memory_list->GetMemoryRegionForAddress(instruction_pointer);
@@ -449,7 +483,7 @@ TEST_F(ExceptionHandlerTest, InstructionPointerMemoryMaxBound) {
   pid_t pid = fork();
   if (pid == 0) {
     close(fds[0]);
-    ExceptionHandler eh(tempDir.path, NULL, MDCallback, &fds[1], true, NULL);
+    ExceptionHandler eh(tempDir.path(), NULL, MDCallback, &fds[1], true, NULL);
     // Get some executable memory.
     char* memory =
       reinterpret_cast<char*>(mmap(NULL,
@@ -511,20 +545,7 @@ TEST_F(ExceptionHandlerTest, InstructionPointerMemoryMaxBound) {
   ASSERT_TRUE(context);
 
   u_int64_t instruction_pointer;
-  switch (context->GetContextCPU()) {
-  case MD_CONTEXT_X86:
-    instruction_pointer = context->GetContextX86()->eip;
-    break;
-  case MD_CONTEXT_AMD64:
-    instruction_pointer = context->GetContextAMD64()->rip;
-    break;
-  case MD_CONTEXT_ARM:
-    instruction_pointer = context->GetContextARM()->iregs[15];
-    break;
-  default:
-    FAIL() << "Unknown context CPU: " << context->GetContextCPU();
-    break;
-  }
+  ASSERT_TRUE(context->GetInstructionPointer(&instruction_pointer));
 
   MinidumpMemoryRegion* region =
     memory_list->GetMemoryRegionForAddress(instruction_pointer);
@@ -552,7 +573,7 @@ TEST_F(ExceptionHandlerTest, InstructionPointerMemoryNullPointer) {
   pid_t pid = fork();
   if (pid == 0) {
     close(fds[0]);
-    ExceptionHandler eh(tempDir.path, NULL, MDCallback, &fds[1], true, NULL);
+    ExceptionHandler eh(tempDir.path(), NULL, MDCallback, &fds[1], true, NULL);
     // Try calling a NULL pointer.
     typedef void (*void_function)(void);
     void_function memory_function =
@@ -594,4 +615,63 @@ TEST_F(ExceptionHandlerTest, InstructionPointerMemoryNullPointer) {
   ASSERT_EQ((unsigned int)1, memory_list->region_count());
 }
 
+static void *Junk(void *) {
+  sleep(1000000);
+  return NULL;
+}
+
+// Test that the memory list gets written correctly when multiple
+// threads are running.
+TEST_F(ExceptionHandlerTest, MemoryListMultipleThreads) {
+  // Give the child process a pipe to report back on.
+  int fds[2];
+  ASSERT_EQ(0, pipe(fds));
+
+  pid_t pid = fork();
+  if (pid == 0) {
+    close(fds[0]);
+    ExceptionHandler eh(tempDir.path(), NULL, MDCallback, &fds[1], true, NULL);
+
+    // Run an extra thread so >2 memory regions will be written.
+    pthread_t junk_thread;
+    if (pthread_create(&junk_thread, NULL, Junk, NULL) == 0)
+      pthread_detach(junk_thread);
+
+    // Just crash.
+    Crasher();
+
+    // not reached
+    exit(1);
+  }
+  // In the parent process.
+  ASSERT_NE(-1, pid);
+  close(fds[1]);
+
+  // Wait for the background process to return the minidump file.
+  close(fds[1]);
+  char minidump_file[PATH_MAX];
+  ssize_t nbytes = read(fds[0], minidump_file, sizeof(minidump_file));
+  ASSERT_NE(0, nbytes);
+  // Ensure that minidump file exists and is > 0 bytes.
+  struct stat st;
+  ASSERT_EQ(0, stat(minidump_file, &st));
+  ASSERT_LT(0, st.st_size);
+
+  // Child process should have exited with a zero status.
+  int ret;
+  ASSERT_EQ(pid, waitpid(pid, &ret, 0));
+  EXPECT_NE(0, WIFEXITED(ret));
+  EXPECT_EQ(0, WEXITSTATUS(ret));
+
+  // Read the minidump, and verify that the memory list can be read.
+  Minidump minidump(minidump_file);
+  ASSERT_TRUE(minidump.Read());
+
+  MinidumpMemoryList* memory_list = minidump.GetMemoryList();
+  ASSERT_TRUE(memory_list);
+  // Verify that there are three memory regions:
+  // one per thread, and one for the instruction pointer memory.
+  ASSERT_EQ((unsigned int)3, memory_list->region_count());
+}
+
 }