Cleans up our autorelease handling so that we don't create a layered ...

chrome/browser/chrome_browser_application_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/browser/chrome_application_mac.h"
+#import "chrome/browser/chrome_browser_application_mac.h"
 
 #import "base/histogram.h"
 #import "base/logging.h"
 #import "base/scoped_nsobject.h"
 #import "base/sys_string_conversions.h"
 #import "chrome/app/breakpad_mac.h"
 #import "chrome/browser/cocoa/chrome_event_processing_window.h"
 #import "chrome/browser/cocoa/objc_method_swizzle.h"
-#import "chrome/browser/renderer_host/render_widget_host_view_mac.h"
 
 // The implementation of NSExceptions break various assumptions in the
 // Chrome code.  This category defines a replacement for
 // -initWithName:reason:userInfo: for purposes of forcing a break in
 // the debugger when an exception is raised.  -raise sounds more
 // obvious to intercept, but it doesn't catch the original throw
 // because the objc runtime doesn't use it.
 @interface NSException (NSExceptionSwizzle)
 - (id)chromeInitWithName:(NSString *)aName
                   reason:(NSString *)aReason
@@ skipping 17 matching lines @@
   DLOG(ERROR) << "Someone is preparing to raise an exception!  "
               << base::SysNSStringToUTF8(aName) << " *** "
               << base::SysNSStringToUTF8(aReason);
   NOTREACHED();
 
   // Forward to the original version.
   return gOriginalInitIMP(self, _cmd, aName, aReason, someUserInfo);
 }
 @end
 
-namespace CrApplicationNSException {
+namespace chrome_browser_application_mac {
 
 // Maximum number of known named exceptions we'll support.  There is
 // no central registration, but I only find about 75 possibilities in
 // the system frameworks, and many of them are probably not
 // interesting to track in aggregate (those relating to distributed
 // objects, for instance).
 const size_t kKnownNSExceptionCount = 25;
 
 const size_t kUnknownNSException = kKnownNSExceptionCount;
 
@@ skipping 29 matching lines @@
   return kUnknownNSException;
 }
 
 void RecordExceptionWithUma(NSException* exception) {
   static LinearHistogram histogram("OSX.NSException", 0, kUnknownNSException,
                                    kUnknownNSException + 1);
   histogram.SetFlags(kUmaTargetedHistogramFlag);
   histogram.Add(BinForException(exception));
 }
 
-}  // CrApplicationNSException
+void Terminate() {
+  [NSApp terminate:nil];
+}
+
+}  // namespace chrome_browser_application_mac
 
 namespace {
 
 // Helper to make it easy to get crash keys right.
 // TODO(shess): Find a better home for this.  app/breakpad_mac.h
 // doesn't work.
 class ScopedCrashKey {
  public:
   ScopedCrashKey(NSString* key, NSString* value)
       : crash_key_([key retain]) {
@@ skipping 13 matching lines @@
 BOOL SwizzleNSExceptionInit() {
   gOriginalInitIMP = ObjcEvilDoers::SwizzleImplementedInstanceMethods(
       [NSException class],
       @selector(initWithName:reason:userInfo:),
       @selector(chromeInitWithName:reason:userInfo:));
   return YES;
 }
 
 }  // namespace
 
-@implementation CrApplication
+@implementation BrowserCrApplication
 
 - init {
-  // TODO(shess): Push this somewhere where it can apply to the plugin
-  // and renderer processes, and where it can intercept uncaught
-  // exceptions.
   DCHECK(SwizzleNSExceptionInit());
   return [super init];
 }
 
 // -terminate: is the entry point for orderly "quit" operations in Cocoa.
 // This includes the application menu's quit menu item and keyboard
 // equivalent, the application's dock icon menu's quit menu item, "quit" (not
 // "force quit") in the Activity Monitor, and quits triggered by user logout
 // and system restart and shutdown.
 //
@@ skipping 85 matching lines @@
   NSString* actionString = NSStringFromSelector(anAction);
   NSString* value =
         [NSString stringWithFormat:@"%@ tag %d sending %@ to %p",
                   [sender className], tag, actionString, aTarget];
 
   ScopedCrashKey key(kActionKey, value);
   return [super sendAction:anAction to:aTarget from:sender];
 }
 
 - (void)sendEvent:(NSEvent*)event {
+  chrome_application_mac::ScopedSendingEvent scoper(self);
   // The superclass's |sendEvent:| sends keyboard events to the menu and the key
   // view loop before dispatching them to |keyDown:|. Since we want to send keys
   // to the renderer before sending them to the menu, and we never want them to
   // the kev view loop when the web is focussed, we change this behavior.
   if ([[self keyWindow]
       isKindOfClass:[ChromeEventProcessingWindow class]]) {
     if ([static_cast<ChromeEventProcessingWindow*>([self keyWindow])
         shortcircuitEvent:event])
       return;
   }
 
   [super sendEvent:event];
 }
 
 // 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;
-    CrApplicationNSException::RecordExceptionWithUma(anException);
+    chrome_browser_application_mac::RecordExceptionWithUma(anException);
 
     // 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 const NSString* kFirstExceptionKey = @"firstexception";
     static BOOL trackedFirstException = NO;
     static const NSString* kLastExceptionKey = @"lastexception";
@@ skipping 16 matching lines @@
       SetCrashKeyValue(kLastExceptionKey, value);
     }
 
     reportingException = NO;
   }
 
   [super reportException:anException];
 }
 
 @end
-
-namespace CrApplicationCC {
-
-void Terminate() {
-  [NSApp terminate:nil];
-}
-
-}  // namespace CrApplicationCC