Mac/clang: Possibly contentious changes.

chrome/browser/chrome_browser_application_mac.mm

 // Copyright (c) 2010 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/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/app_controller_mac.h"
 #import "chrome/browser/cocoa/objc_method_swizzle.h"
 #import "chrome/browser/cocoa/objc_zombie.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
+- (id)chromeInitWithName:(NSString*)aName
+                  reason:(NSString*)aReason
                 userInfo:(NSDictionary *)someUserInfo;
 @end
 
 static IMP gOriginalInitIMP = NULL;
 
 @implementation NSException (NSExceptionSwizzle)
-- (id)chromeInitWithName:(NSString *)aName
-                  reason:(NSString *)aReason
+- (id)chromeInitWithName:(NSString*)aName
+                  reason:(NSString*)aReason
                 userInfo:(NSDictionary *)someUserInfo {
   // Method only called when swizzled.
   DCHECK(_cmd == @selector(initWithName:reason:userInfo:));
 
   // Parts of Cocoa rely on creating and throwing exceptions. These are not
   // worth bugging-out over. It is very important that there be zero chance that
   // any Chromium code is on the stack; these must be created by Apple code and
   // then immediately consumed by Apple code.
-  static const NSString* kAcceptableNSExceptionNames[] = {
+  static NSString* const kAcceptableNSExceptionNames[] = {
     // If an object does not support an accessibility attribute, this will
     // get thrown.
     NSAccessibilityException,
 
     nil
   };
 
   BOOL found = NO;
   for (int i = 0; kAcceptableNSExceptionNames[i]; ++i) {
     if (aName == kAcceptableNSExceptionNames[i]) {
@@ skipping 26 matching lines @@
 // interesting to track in aggregate (those relating to distributed
 // objects, for instance).
 const size_t kKnownNSExceptionCount = 25;
 
 const size_t kUnknownNSException = kKnownNSExceptionCount;
 
 size_t BinForException(NSException* exception) {
   // A list of common known exceptions.  The list position will
   // determine where they live in the histogram, so never move them
   // around, only add to the end.
-  static const NSString* kKnownNSExceptionNames[] = {
+  static NSString* const kKnownNSExceptionNames[] = {
     // ???
     NSGenericException,
 
     // Out-of-range on NSString or NSArray.
     NSRangeException,
 
     // Invalid arg to method, unrecognized selector.
     NSInvalidArgumentException,
 
     // malloc() returned null in object creation, I think.
     NSMallocException,
 
     nil
   };
 
   // Make sure our array hasn't outgrown our abilities to track it.
   DCHECK_LE(arraysize(kKnownNSExceptionNames), kKnownNSExceptionCount);
 
-  const NSString* name = [exception name];
+  NSString* name = [exception name];
   for (int i = 0; kKnownNSExceptionNames[i]; ++i) {
     if (name == kKnownNSExceptionNames[i]) {
       return i;
     }
   }
   return kUnknownNSException;
 }
 
 void RecordExceptionWithUma(NSException* exception) {
   UMA_HISTOGRAM_ENUMERATION("OSX.NSException",
@@ skipping 151 matching lines @@
       }
     }
     if (!found) {
       return NO;
     }
   }
 
   // When a Cocoa control is wired to a freed object, we get crashers
   // in the call to |super| with no useful information in the
   // backtrace.  Attempt to add some useful information.
-  static const NSString* kActionKey = @"sendaction";
+  static NSString* const kActionKey = @"sendaction";
 
   // If the action is something generic like -commandDispatch:, then
   // the tag is essential.
   NSInteger tag = 0;
   if ([sender isKindOfClass:[NSControl class]]) {
     tag = [sender tag];
     if (tag == 0 || tag == -1) {
       tag = [sender selectedTag];
     }
   } else if ([sender isKindOfClass:[NSMenuItem class]]) {
@@ skipping 21 matching lines @@
   if (!reportingException) {
     reportingException = YES;
     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 NSString* const kFirstExceptionKey = @"firstexception";
     static BOOL trackedFirstException = NO;
-    static const NSString* kLastExceptionKey = @"lastexception";
+    static NSString* const kLastExceptionKey = @"lastexception";
 
     // TODO(shess): It would be useful to post some stacktrace info
     // from the exception.
     // 10.6 has -[NSException callStackSymbols]
     // 10.5 has -[NSException callStackReturnAddresses]
     // 10.5 has backtrace_symbols().
     // I've tried to combine the latter two, but got nothing useful.
     // The addresses are right, though, maybe we could train the crash
     // server to decode them for us.
 
     NSString* value = [NSString stringWithFormat:@"%@ reason %@",
                                 [anException name], [anException reason]];
     if (!trackedFirstException) {
       SetCrashKeyValue(kFirstExceptionKey, value);
       trackedFirstException = YES;
     } else {
       SetCrashKeyValue(kLastExceptionKey, value);
     }
 
     reportingException = NO;
   }
 
   [super reportException:anException];
 }
 
 @end