Create a nicer interface for base::mac::GetValueFromDictionary

base/mac/foundation_util.h

 // 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.
 
 #ifndef BASE_MAC_FOUNDATION_UTIL_H_
 #define BASE_MAC_FOUNDATION_UTIL_H_
 #pragma once
 
 #include <CoreFoundation/CoreFoundation.h>
 
 #include <string>
 #include <vector>
 
 #include "base/base_export.h"
 #include "base/logging.h"
+#include "base/mac/scoped_cftyperef.h"
 
 #if defined(__OBJC__)
 #import <Foundation/Foundation.h>
 #else  // __OBJC__
 class NSBundle;
 class NSString;
 #endif  // __OBJC__
 
 class FilePath;
 
@@ skipping 63 matching lines @@
 // Returns the ~/Library directory.
 BASE_EXPORT FilePath GetUserLibraryPath();
 
 // Takes a path to an (executable) binary and tries to provide the path to an
 // application bundle containing it. It takes the outermost bundle that it can
 // find (so for "/Foo/Bar.app/.../Baz.app/..." it produces "/Foo/Bar.app").
 //   |exec_name| - path to the binary
 //   returns - path to the application bundle, or empty on error
 BASE_EXPORT FilePath GetAppBundlePath(const FilePath& exec_name);
 
+#define TYPE_NAME_FOR_CF_TYPE_DECL(TypeCF) \
+std::string TypeNameForCFType(TypeCF##Ref);
+
+TYPE_NAME_FOR_CF_TYPE_DECL(CFArray);
+TYPE_NAME_FOR_CF_TYPE_DECL(CFBag);
+TYPE_NAME_FOR_CF_TYPE_DECL(CFBoolean);
+TYPE_NAME_FOR_CF_TYPE_DECL(CFData);
+TYPE_NAME_FOR_CF_TYPE_DECL(CFDate);
+TYPE_NAME_FOR_CF_TYPE_DECL(CFDictionary);
+TYPE_NAME_FOR_CF_TYPE_DECL(CFNull);
+TYPE_NAME_FOR_CF_TYPE_DECL(CFNumber);
+TYPE_NAME_FOR_CF_TYPE_DECL(CFSet);
+TYPE_NAME_FOR_CF_TYPE_DECL(CFString);
+
+#undef TYPE_NAME_FOR_CF_TYPE_DECL
+
+// Helper function for GetValueFromDictionary to create the error message
+// that appears when a type mismatch is encountered.
+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.
+// This is now deprecated in favor of the two-argument form below.
+// TODO(kushi.p)

[Mark Mentovai, 2011/11/14 22:11:37]

Please finish this comment by referencing your newly-filed bug and saying what
the TODO means.

Reference:
http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml?showone=Castin...

Further reference:
https://groups.google.com/a/chromium.org/group/chromium-dev/browse_thread/thr...

 BASE_EXPORT CFTypeRef GetValueFromDictionary(CFDictionaryRef dict,
                                              CFStringRef key,
                                              CFTypeID expected_type);
 
 // Retain/release calls for memory management in C++.
 BASE_EXPORT void NSObjectRetain(void* obj);
 BASE_EXPORT void NSObjectRelease(void* obj);
 
 // CFTypeRefToNSObjectAutorelease transfers ownership of a Core Foundation
 // object (one derived from CFTypeRef) to the Foundation memory management
@@ skipping 80 matching lines @@
 CF_TO_NS_CAST_DECL(CFLocale, NSLocale);
 CF_TO_NS_CAST_DECL(CFNumber, NSNumber);
 CF_TO_NS_CAST_DECL(CFRunLoopTimer, NSTimer);
 CF_TO_NS_CAST_DECL(CFTimeZone, NSTimeZone);
 CF_TO_NS_MUTABLE_CAST_DECL(Set);
 CF_TO_NS_CAST_DECL(CFReadStream, NSInputStream);
 CF_TO_NS_CAST_DECL(CFWriteStream, NSOutputStream);
 CF_TO_NS_MUTABLE_CAST_DECL(String);
 CF_TO_NS_CAST_DECL(CFURL, NSURL);
 
+#undef CF_TO_NS_CAST_DECL
+#undef CF_TO_NS_MUTABLE_CAST_DECL

[Mark Mentovai, 2011/11/14 22:13:21]

I said three, right?

How about OBJC_CPP_CLASS_DECL?

[KushalP, 2011/11/14 22:20:47]

Ah, thought you just mean this 10 line block here.

+
 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.
 //
 // Example usage:
 // CFNumberRef some_number = base::mac::CFCast<CFNumberRef>(
 //     CFArrayGetValueAtIndex(array, index));
 //
 // CFStringRef some_string = base::mac::CFCastStrict<CFStringRef>(
 //     base::mac::GetValueFromDictionary(some_dict,
 //                                       CFSTR("a_key"),
 //                                       CFStringGetTypeID()));
-BASE_EXPORT template<class T>
+BASE_EXPORT template<typename T>
 T CFCast(const CFTypeRef& cf_val);
 
-BASE_EXPORT template<class T>
+BASE_EXPORT template<typename T>
 T CFCastStrict(const CFTypeRef& cf_val);
 
 #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.
 //
 // 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.
 //
 // Example usage:
 // NSString* version = base::mac::ObjCCast<NSString>(
 //     [bundle objectForInfoDictionaryKey:@"CFBundleShortVersionString"]);
 //
 // NSString* str = base::mac::ObjCCastStrict<NSString>(
 //     [ns_arr_of_ns_strs objectAtIndex:0]);
-BASE_EXPORT template<class T>
+BASE_EXPORT template<typename T>
 T* ObjCCast(id objc_val) {
   if ([objc_val isKindOfClass:[T class]]) {
     return reinterpret_cast<T*>(objc_val);
   }
   return nil;
 }
 
-BASE_EXPORT template<class T>
+BASE_EXPORT template<typename T>
 T* ObjCCastStrict(id objc_val) {
   T* rv = ObjCCast<T>(objc_val);
   DCHECK(objc_val == nil || rv);
   return rv;
 }
 
 #endif  // defined(__OBJC__)
 
+// 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.
+BASE_EXPORT template<typename T>
+T GetValueFromDictionary(CFDictionaryRef dict, CFStringRef key) {
+  CFTypeRef value = CFDictionaryGetValue(dict, key);
+  T value_specific = CFCast<T>(value);
+
+  if (value && !value_specific) {
+    std::string expected_type = TypeNameForCFType(value_specific);
+    DLOG(WARNING) << GetValueFromDictionaryErrorMessage(key,
+                                                        expected_type,
+                                                        value);
+  }
+
+  return value_specific;
+}
+
 }  // namespace mac
 }  // namespace base
 
 // Stream operations for CFTypes. They can be used with NSTypes as well
 // 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_