More OS X Breakpad integration

chrome/app/breakpad_mac.mm

 // Copyright (c) 2009 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #import "chrome/app/breakpad_mac.h"
 
-#import <dlfcn.h>
 #import <Foundation/Foundation.h>
 
+#include "base/base_switches.h"
 #import "base/basictypes.h"
+#include "base/command_line.h"
 #import "base/logging.h"
 #import "base/scoped_nsautorelease_pool.h"
+#include "base/sys_string_conversions.h"
+#import "breakpad/src/client/mac/Framework/Breakpad.h"
 
-// For definition of SetActiveRendererURL().
-#import "chrome/renderer/renderer_logging.h"
-#import "googleurl/src/gurl.h"
+#if !defined(GOOGLE_CHROME_BUILD)
+// If we aren't compiling as a branded build, then add dummy versions of the
+// Breakpad functions so we don't have to link against Breakpad.
 
-// TODO(jeremy): On Windows we store the current URL when a process crashes
-// we probably want to do the same on OS X.
+BreakpadRef BreakpadCreate(NSDictionary *parameters) {
+  NOTREACHED();
+  return NULL;
+}
+
+void BreakpadRelease(BreakpadRef ref) {
+  NOTREACHED();
+}
+
+void BreakpadSetKeyValue(BreakpadRef ref, NSString *key, NSString *value) {
+  NOTREACHED();
+}
+
+void BreakpadRemoveKeyValue(BreakpadRef ref, NSString *key) {
+  NOTREACHED();
+}
+
+#endif  // !defined(GOOGLE_CHROME_BUILD)
 
 namespace {
 
-// TODO(jeremy): Remove this block once we include the breakpad sources
-// in the public tree.
-typedef void* GoogleBreakpadRef;
-
-typedef void (*GoogleBreakpadSetKeyValuePtr) (GoogleBreakpadRef, NSString*,
-                                              NSString*);
-typedef void (*GoogleBreakpadRemoveKeyValuePtr) (GoogleBreakpadRef, NSString*);
-typedef GoogleBreakpadRef (*GoogleBreakPadCreatePtr) (NSDictionary*);
-typedef void (*GoogleBreakPadReleasePtr) (GoogleBreakpadRef);
-
-
-GoogleBreakpadRef gBreakpadRef = NULL;
-GoogleBreakPadCreatePtr gBreakPadCreateFunc = NULL;
-GoogleBreakPadReleasePtr gBreakPadReleaseFunc = NULL;
-GoogleBreakpadSetKeyValuePtr gBreakpadSetKeyValueFunc = NULL;
-GoogleBreakpadRemoveKeyValuePtr gBreakpadRemoveKeyValueFunc = NULL;
+BreakpadRef gBreakpadRef = NULL;
 
 // Did the user optin for reporting stats.
 bool IsStatsReportingAllowed() {
   NOTIMPLEMENTED();
   return true;
 }
 
 } // namespace
 
 bool IsCrashReporterEnabled() {
   return gBreakpadRef == NULL;
 }
 
 void DestructCrashReporter() {
   if (gBreakpadRef) {
-    DCHECK(gBreakPadReleaseFunc != NULL);
-    gBreakPadReleaseFunc(gBreakpadRef);
+    BreakpadRelease(gBreakpadRef);
     gBreakpadRef = NULL;
   }
 }
 
 void InitCrashReporter() {

[John Grabowski, 2009/04/22 00:01:58]

Add a comment that InitCrashReporter() is only called for a branded build

   DCHECK(gBreakpadRef == NULL);
   base::ScopedNSAutoreleasePool autorelease_pool;
 
   // Check for Send stats preference. If preference is not specifically turned
   // on then disable crash reporting.
   if (!IsStatsReportingAllowed()) {
     LOG(WARNING) << "Breakpad disabled";
     return;
   }
 
   NSBundle* main_bundle = [NSBundle mainBundle];
-
-  // Get location of breakpad.
-  NSString* breakpadBundlePath = [[main_bundle privateFrameworksPath]
-      stringByAppendingPathComponent:@"GoogleBreakpad.framework"];
-
-  BOOL is_dir = NO;
-  if (![[NSFileManager defaultManager] fileExistsAtPath:breakpadBundlePath
-                                            isDirectory:&is_dir] || !is_dir) {
-    return;
-  }
-
-  NSBundle* breakpad_bundle = [NSBundle bundleWithPath:breakpadBundlePath];
-  if (![breakpad_bundle load]) {
-     LOG(ERROR) << "Failed to load Breakpad framework.";
-    return;
-  }
-
-  // Retrieve Breakpad interface functions.
-  gBreakPadCreateFunc = reinterpret_cast<GoogleBreakPadCreatePtr>(
-      dlsym(RTLD_DEFAULT, "GoogleBreakpadCreate"));
-  gBreakPadReleaseFunc = reinterpret_cast<GoogleBreakPadReleasePtr>(
-      dlsym(RTLD_DEFAULT, "GoogleBreakpadRelease"));
-  gBreakpadSetKeyValueFunc = reinterpret_cast<GoogleBreakpadSetKeyValuePtr>(
-      dlsym(RTLD_DEFAULT, "GoogleBreakpadSetKeyValue"));
-  gBreakpadRemoveKeyValueFunc =
-      reinterpret_cast<GoogleBreakpadRemoveKeyValuePtr>(
-          dlsym(RTLD_DEFAULT, "GoogleBreakpadRemoveKeyValue"));
-
-  if (!gBreakPadCreateFunc || !gBreakPadReleaseFunc
-      || !gBreakpadSetKeyValueFunc || !gBreakpadRemoveKeyValueFunc) {
-    LOG(ERROR) << "Failed to find Breakpad wrapper classes.";
-    return;
-  }
+  NSString* resource_path = [main_bundle resourcePath];
 
   NSDictionary* info_dictionary = [main_bundle infoDictionary];
-  GoogleBreakpadRef breakpad = NULL;
-  breakpad = gBreakPadCreateFunc(info_dictionary);
+  NSMutableDictionary *breakpad_config = [info_dictionary
+                                             mutableCopy];
+
+  // Tell Breakpad where inspector & crash_reporter are.
+  NSString *inspector_location = [resource_path
+      stringByAppendingPathComponent:@"crash_inspector"];
+  NSString *reporter_bundle_location = [resource_path
+      stringByAppendingPathComponent:@"crash_report_sender.app"];
+  NSString *reporter_location = [[NSBundle
+                                      bundleWithPath:reporter_bundle_location]
+                                     executablePath];
+
+  [breakpad_config setObject:inspector_location
+                      forKey:@BREAKPAD_INSPECTOR_LOCATION];
+  [breakpad_config setObject:reporter_location
+                      forKey:@BREAKPAD_REPORTER_EXE_LOCATION];
+
+  // Init breakpad
+  BreakpadRef breakpad = NULL;
+  breakpad = BreakpadCreate(breakpad_config);
   if (!breakpad) {
     LOG(ERROR) << "Breakpad init failed.";
     return;
   }
 
-  // TODO(jeremy): determine whether we're running in the browser or
-  // renderer processes.
-  bool is_renderer = false;
-
   // This needs to be set before calling SetCrashKeyValue().
   gBreakpadRef = breakpad;
 
   // Set breakpad MetaData values.
-  NSString* version_str = [info_dictionary objectForKey:@"CFBundleVersion"];
+  NSString* version_str = [info_dictionary objectForKey:@BREAKPAD_VERSION];

[John Grabowski, 2009/04/22 00:01:58]

Feedback not applied or responded on this line

   SetCrashKeyValue(@"ver", version_str);
-  NSString* prod_name_str = [info_dictionary objectForKey:@"CFBundleExecutable"];
+  NSString* prod_name_str = [info_dictionary objectForKey:@BREAKPAD_PRODUCT];
   SetCrashKeyValue(@"prod", prod_name_str);
   SetCrashKeyValue(@"plat", @"OS X");
-  NSString *product_type = is_renderer ? @"renderer" : @"browser";
-  SetCrashKeyValue(@"ptype", product_type);
+}
+
+void InitCrashProcessInfo() {
+  if (gBreakpadRef == NULL) {
+    return;
+  }
+
+  // Determine the process type.
+  NSString *process_type = @"browser";
+  const CommandLine& parsed_command_line = *CommandLine::ForCurrentProcess();
+  std::wstring process_type_switch =
+      parsed_command_line.GetSwitchValue(switches::kProcessType);
+  if (!process_type_switch.empty()) {
+    process_type = base::SysWideToNSString(process_type_switch);
+  }
+
+  // Store process type in crash dump.
+  SetCrashKeyValue(@"ptype", process_type);
 }
 
 void SetCrashKeyValue(NSString* key, NSString* value) {
   // Comment repeated from header to prevent confusion:
   // IMPORTANT: On OS X, the key/value pairs are sent to the crash server
   // out of bounds and not recorded on disk in the minidump, this means
   // that if you look at the minidump file locally you won't see them!
   if (gBreakpadRef == NULL) {
     return;
   }
 
-  DCHECK(gBreakpadSetKeyValueFunc != NULL);
-  gBreakpadSetKeyValueFunc(gBreakpadRef, key, value);
+  BreakpadSetKeyValue(gBreakpadRef, key, value);
 }
 
 void ClearCrashKeyValue(NSString* key) {
   if (gBreakpadRef == NULL) {
     return;
   }
 
-  DCHECK(gBreakpadRemoveKeyValueFunc != NULL);
-  gBreakpadRemoveKeyValueFunc(gBreakpadRef, key);
+  BreakpadRemoveKeyValue(gBreakpadRef, key);
 }