[Mac] Allow NSExceptions in certain cases.

chrome/browser/chrome_browser_application_mac.mm

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #import "chrome/browser/chrome_browser_application_mac.h"
 
 #import "base/logging.h"
+#import "base/mac/scoped_nsexception_enabler.h"
 #import "base/metrics/histogram.h"
 #import "base/memory/scoped_nsobject.h"
 #import "base/sys_string_conversions.h"
 #import "chrome/app/breakpad_mac.h"
 #include "chrome/browser/accessibility/browser_accessibility_state.h"
 #import "chrome/browser/app_controller_mac.h"
 #include "chrome/browser/ui/browser_list.h"
 #import "chrome/browser/ui/cocoa/objc_method_swizzle.h"
 #import "chrome/browser/ui/cocoa/objc_zombie.h"
 #include "chrome/browser/ui/tab_contents/tab_contents_wrapper.h"
@@ skipping 68 matching lines @@
     if (aName == NSInvalidArgumentException) {
       fatal = YES;
     }
 
     // Dear reader: Something you just did provoked an NSException.
     // NSException is implemented in terms of setjmp()/longjmp(),
     // which does poor things when combined with C++ scoping
     // (destructors are skipped).  Chrome should be NSException-free,
     // please check your backtrace and see if you can't file a bug
     // with a repro case.
-    if (fatal) {
+    const bool allow = base::mac::GetNSExceptionsAllowed();
+    if (fatal && !allow) {
       LOG(FATAL) << "Someone is trying to raise an exception!  "
                  << base::SysNSStringToUTF8(value);
     } else {
       // Make sure that developers see when their code throws
       // exceptions.
       DLOG(ERROR) << "Someone is trying to raise an exception!  "
                   << base::SysNSStringToUTF8(value);
-      NOTREACHED();
+      DCHECK(allow);
     }
   }
 
   // Forward to the original version.
   return gOriginalInitIMP(self, _cmd, aName, aReason, someUserInfo);
 }
 @end
 
 namespace chrome_browser_application_mac {
 
@@ skipping 206 matching lines @@
     }
   } else if ([sender isKindOfClass:[NSMenuItem class]]) {
     tag = [sender tag];
   }
 
   NSString* actionString = NSStringFromSelector(anAction);
   NSString* value =
         [NSString stringWithFormat:@"%@ tag %d sending %@ to %p",
                   [sender className], tag, actionString, aTarget];
 
+  // Certain third-party code, such as print drivers, can still throw
+  // exceptions and Chromium cannot fix them.  This provides a way to
+  // work around those on a spot basis.
+  bool enableNSExceptions = false;
+
+  // http://crbug.com/80686 , an Epson printer driver.
+  if (anAction == @selector(selectPDE:)) {
+    enableNSExceptions = true;
+  }
+
+  // These should be as close to the super call as reasonable.
+  base::mac::ScopedNSExceptionEnabler enabler(enableNSExceptions);
   ScopedCrashKey key(kActionKey, value);

[Mark Mentovai, 2011/05/17 22:23:27]

Can’t this precede ScopedNSExceptionEnabler? You can still put it after the
logic that sets enableNSExceptions. (And you can still put the logic that sets
enableNSExceptions above the thing that figures out actionString and value, so
that those can stay right next to the ScopedCrashKey for kActionKey.)

[Scott Hess - ex-Googler, 2011/05/17 22:48:30]

I'm not entirely sure I understand what you'd like to see.  One has to come
first, one has to come second, but they can generally be in any old order and
the additional exposure of one order versus the other is pretty minimal.  The
reason I pulled setting |enableNSExceptions| down by using it was just because
it seemed like keeping the new code all together was somewhat valuable.

I'll grant a slight win to not allowing exceptions while setting a
ScopedCrashKey.

+
   return [super sendAction:anAction to:aTarget from:sender];
 }
 
 // NSExceptions which are caught by the event loop are logged here.
 // NSException uses setjmp/longjmp, which can be very bad for C++, so
 // we attempt to track and report them.
 - (void)reportException:(NSException *)anException {
   // If we throw an exception in this code, we can create an infinite
   // loop.  If we throw out of the if() without resetting
   // |reportException|, we'll stop reporting exceptions for this run.
   static BOOL reportingException = NO;
   DCHECK(!reportingException);
   if (!reportingException) {
     reportingException = YES;
     chrome_browser_application_mac::RecordExceptionWithUma(anException);
 
     // http://crbug.com/45928 is a bug about needing to double-close
     // windows sometimes.  One theory is that |-isHandlingSendEvent|
     // gets latched to always return |YES|.  Since scopers are used to
     // manipulate that value, that should not be possible.  One way to
     // sidestep scopers is setjmp/longjmp (see above).  The following
     // is to "fix" this while the more fundamental concern is
     // addressed elsewhere.
     [self clearIsHandlingSendEvent];
 
+    // If |ScopedNSExceptionEnabler| is used to allow exceptions, and
+    // an uncaught exception is thrown, the flag must be reset so that
+    // future exceptions are not masked.

[Mark Mentovai, 2011/05/17 22:23:27]

Can you at least say here that stuff will have unwound past the outermost
ScopedNSExceptionEnabler?

[Scott Hess - ex-Googler, 2011/05/17 22:48:30]

OK.

+    base::mac::SetNSExceptionsAllowed(false);
+
     // Store some human-readable information in breakpad keys in case
     // there is a crash.  Since breakpad does not provide infinite
     // storage, we track two exceptions.  The first exception thrown
     // is tracked because it may be the one which caused the system to
     // go off the rails.  The last exception thrown is tracked because
     // it may be the one most directly associated with the crash.
     static NSString* const kFirstExceptionKey = @"firstexception";
     static BOOL trackedFirstException = NO;
     static NSString* const kLastExceptionKey = @"lastexception";
 
@@ skipping 32 matching lines @@
         if (RenderViewHost* rvh = contents->render_view_host()) {
           rvh->EnableRendererAccessibility();
         }
       }
     }
   }
   return [super accessibilitySetValue:value forAttribute:attribute];
 }
 
 @end