Mac: Introduce "StaticCast" variants of base::mac::FooCastStrict, which do not typecheck in Release

base/mac/foundation_util.h

 // Copyright (c) 2012 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.
 
 #ifndef BASE_MAC_FOUNDATION_UTIL_H_
 #define BASE_MAC_FOUNDATION_UTIL_H_
 
 #include <CoreFoundation/CoreFoundation.h>
 
 #include <string>
@@ skipping 234 matching lines @@
 CF_TO_NS_CAST_DECL(CTFont, NSFont);
 #endif
 
 #undef CF_TO_NS_CAST_DECL
 #undef CF_TO_NS_MUTABLE_CAST_DECL
 #undef OBJC_CPP_CLASS_DECL
 
 namespace base {
 namespace mac {
 
-// CFCast<>() and CFCastStrict<>() cast a basic CFTypeRef to a more
-// specific CoreFoundation type. The compatibility of the passed
-// object is found by comparing its opaque type against the
-// requested type identifier. If the supplied object is not
-// compatible with the requested return type, CFCast<>() returns
-// NULL and CFCastStrict<>() will DCHECK. Providing a NULL pointer
-// to either variant results in NULL being returned without
-// triggering any DCHECK.
+// CFCast<>(), CFCastStrict<>() and CFStaticCast<> cast a basic CFTypeRef to a
+// more specific CoreFoundation type. The compatibility of the passed object is
+// found by comparing its opaque type against the requested type identifier. If
+// the supplied object is not compatible with the requested return type:
+//  - CFCast<>() returns null, similar to dynamic_cast<>;
+//  - CFCastStrict<>() will DCHECK or return null in Release; and
+//  - CFStaticCast<>() will DCHECK but always cast, similar to static_cast<>.
+// Providing a null pointer to any variant results in null being returned
+// without triggering any DCHECK.
 //
 // Example usage:
 // CFNumberRef some_number = base::mac::CFCast<CFNumberRef>(
 //     CFArrayGetValueAtIndex(array, index));
 //
 // CFTypeRef hello = CFSTR("hello world");
 // CFStringRef some_string = base::mac::CFCastStrict<CFStringRef>(hello);
-
 template<typename T>
 T CFCast(const CFTypeRef& cf_val);
 
 template<typename T>
 T CFCastStrict(const CFTypeRef& cf_val);
 
+template<typename T>
+T CFStaticCast(const CFTypeRef& cf_val) {
+  DCHECK(!cf_val || CFCast<T>(cf_val));
+  // Note: CFTypeRef is const void*, but CGColorRef and some others are non-
+  // const. So this may also cast away a const qualifier.
+  return (T)(cf_val);
+}
+
 #define CF_CAST_DECL(TypeCF) \
 template<> BASE_EXPORT TypeCF##Ref \
 CFCast<TypeCF##Ref>(const CFTypeRef& cf_val);\
 \
 template<> BASE_EXPORT TypeCF##Ref \
 CFCastStrict<TypeCF##Ref>(const CFTypeRef& cf_val);
 
 CF_CAST_DECL(CFArray);
 CF_CAST_DECL(CFBag);
 CF_CAST_DECL(CFBoolean);
@@ skipping 13 matching lines @@
 CF_CAST_DECL(CTFontDescriptor);
 CF_CAST_DECL(CTRun);
 
 CF_CAST_DECL(SecACL);
 CF_CAST_DECL(SecTrustedApplication);
 
 #undef CF_CAST_DECL
 
 #if defined(__OBJC__)
 
-// ObjCCast<>() and ObjCCastStrict<>() cast a basic id to a more
-// specific (NSObject-derived) type. The compatibility of the passed
-// object is found by checking if it's a kind of the requested type
-// identifier. If the supplied object is not compatible with the
-// requested return type, ObjCCast<>() returns nil and
-// ObjCCastStrict<>() will DCHECK. Providing a nil pointer to either
-// variant results in nil being returned without triggering any DCHECK.
+// ObjCCast<>(), ObjCCastStrict<>() and ObjCStaticCast cast a basic id to a more
+// specific (NSObject-derived) type. The compatibility of the passed object is
+// found by checking if it's a kind of the requested type identifier. If the
+// supplied object is not compatible with the requested return type:
+// - ObjCCast<>() returns nil, similar to dynamic_cast<>,
+// - ObjCCastStrict<>() will DCHECK or return nil in Release; and
+// - ObjCStaticCast<>() will DCHECK but always cast, similar to static_cast<>.
+// Providing a nil pointer to any variant results in nil being returned without
+// triggering any DCHECK.
 //
-// The strict variant is useful when retrieving a value from a
-// collection which only has values of a specific type, e.g. an
-// NSArray of NSStrings. The non-strict variant is useful when
-// retrieving values from data that you can't fully control. For
-// example, a plist read from disk may be beyond your exclusive
-// control, so you'd only want to check that the values you retrieve
+// The strict variant is useful when retrieving a value from a collection which
+// only has values of a specific type, e.g. an NSArray of NSStrings. The non-
+// strict variant is useful when retrieving values from data that you can't
+// fully control. For example, a plist read from disk may be beyond your
+// exclusive control, so you'd only want to check that the values you retrieve
 // from it are of the expected types, but not crash if they're not.
+// ObjCStaticCast should be preferred when you have a strong contract specifying
+// the type and good test coverage.
 //
 // Example usage:
 // NSString* version = base::mac::ObjCCast<NSString>(
 //     [bundle objectForInfoDictionaryKey:@"CFBundleShortVersionString"]);
 //
 // NSString* str = base::mac::ObjCCastStrict<NSString>(
 //     [ns_arr_of_ns_strs objectAtIndex:0]);
 template<typename T>
 T* ObjCCast(id objc_val) {
   if ([objc_val isKindOfClass:[T class]]) {
     return reinterpret_cast<T*>(objc_val);
   }
   return nil;
 }
 
 template<typename T>
 T* ObjCCastStrict(id objc_val) {
   T* rv = ObjCCast<T>(objc_val);
   DCHECK(objc_val == nil || rv);
   return rv;
 }
 
+template<typename T>
+T* ObjCStaticCast(id objc_val) {
+  DCHECK(!objc_val || ObjCCast<T>(objc_val));
+  return reinterpret_cast<T*>(objc_val);
+}
+
 #endif  // defined(__OBJC__)
 
 // Helper function for GetValueFromDictionary to create the error message
 // that appears when a type mismatch is encountered.
 BASE_EXPORT std::string GetValueFromDictionaryErrorMessage(
     CFStringRef key, const std::string& expected_type, CFTypeRef value);
 
 // Utility function to pull out a value from a dictionary, check its type, and
 // return it. Returns NULL if the key is not present or of the wrong type.
 template<typename T>
@@ skipping 32 matching lines @@
 // by using the NSToCFCast methods above.
 // e.g. LOG(INFO) << base::mac::NSToCFCast(@"foo");
 // Operator << can not be overloaded for ObjectiveC types as the compiler
 // can not distinguish between overloads for id with overloads for void*.
 BASE_EXPORT extern std::ostream& operator<<(std::ostream& o,
                                             const CFErrorRef err);
 BASE_EXPORT extern std::ostream& operator<<(std::ostream& o,
                                             const CFStringRef str);
 
 #endif  // BASE_MAC_FOUNDATION_UTIL_H_