[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 207 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];
 
   ScopedCrashKey key(kActionKey, value);
+
+  // 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;
+  }
+
+  // Minimize the window by keeping this close to the super call.
+  scoped_ptr<base::mac::ScopedNSExceptionEnabler> enabler(NULL);
+  if (enableNSExceptions)
+    enabler.reset(new base::mac::ScopedNSExceptionEnabler());
   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, it will throw past all of the scopers.
+    // Reset the flag so that future exceptions are not masked.
+    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