[Mac] Remove content/ CrApplication.

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"
 #include "base/mac/crash_logging.h"
 #import "base/mac/scoped_nsexception_enabler.h"
 #import "base/metrics/histogram.h"
@@ skipping 203 matching lines @@
 }
 
 - (id)init {
   SwizzleInit();
   if ((self = [super init])) {
     eventHooks_.reset([[NSMutableArray alloc] init]);
   }
   return self;
 }
 
+// Initialize NSApplication using the custom subclass.  Check whether NSApp
+// was already initialized using another class, because that would break
+// some things.
++ (NSApplication*)sharedApplication {
+  NSApplication* app = [super sharedApplication];
+  if (![NSApp isKindOfClass:self]) {
+    LOG(ERROR) << "NSApp should be of type " << [[self className] UTF8String]

[Robert Sesek, 2011/12/02 17:10:17]

LOG(FATAL)?

[Scott Hess - ex-Googler, 2011/12/02 19:15:25]

My goal was crash-if-debug, but warn-if-release.  I guess the only possible way
that someone could get here in release is if they didn't test some code path, so
crashing would be reasonable ... I guess.

OK, let me argue a different direction.  In the browser executable, not having
the right CrApp stuff can leads to various use-after-free cases, which are bad,
so I'd be willing to wire it as a crash in that case.  In all other ptypes, it's
likely they shouldn't be using this app subclass in the first place, so having
it crash is also reasonable.

Done, for both if() statements.

+               << ", not " << [[NSApp className] UTF8String];
+    DCHECK(false) << "NSApp is of wrong type";
+  }
+  if (!base::MessagePumpMac::UsingCrApp()) {
+    LOG(ERROR) << "MessagePumpMac::Create() was called before "
+               << [[self className] UTF8String] << " was initialized.";
+    DCHECK(false) << "MessagePumpMac is using the wrong pump implementation.";
+  }
+  return app;
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // HISTORICAL COMMENT (by viettrungluu, from
 // http://codereview.chromium.org/1520006 with mild editing):
 //
 // A quick summary of the state of things (before the changes to shutdown):
 //
 // Currently, we are totally hosed (put in a bad state in which Cmd-W does the
 // wrong thing, and which will probably eventually lead to a crash) if we begin
 // quitting but termination is aborted for some reason.
 //
@@ skipping 127 matching lines @@
 }
 
 - (void)addEventHook:(id<CrApplicationEventHookProtocol>)handler {
   [eventHooks_ addObject:handler];
 }
 
 - (void)removeEventHook:(id<CrApplicationEventHookProtocol>)handler {
   [eventHooks_ removeObject:handler];
 }
 
+- (BOOL)isHandlingSendEvent {
+  return handlingSendEvent_;
+}
+
+- (void)setHandlingSendEvent:(BOOL)handlingSendEvent {
+  handlingSendEvent_ = handlingSendEvent;
+}
+
 - (void)sendEvent:(NSEvent*)event {
   base::mac::ScopedSendingEvent sendingEventScoper;
   for (id<CrApplicationEventHookProtocol> handler in eventHooks_.get()) {
     [handler hookForEvent:event];
   }
   [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;
     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];
+    [self setHandlingSendEvent:NO];
 
     // 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
@@ skipping 38 matching lines @@
         if (RenderViewHost* rvh = contents->render_view_host()) {
           rvh->EnableRendererAccessibility();
         }
       }
     }
   }
   return [super accessibilitySetValue:value forAttribute:attribute];
 }
 
 @end