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

base/mac/foundation_util.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.
 
 #include "base/mac/foundation_util.h"
 
 #include <stdlib.h>
 #include <string.h>
 
 #include "base/file_path.h"
 #include "base/logging.h"
-#include "base/mac/scoped_cftyperef.h"
 #include "base/sys_string_conversions.h"
 
 namespace base {
 namespace mac {
 
 static bool g_override_am_i_bundled = false;
 static bool g_override_am_i_bundled_value = false;
 
 // Adapted from http://developer.apple.com/carbon/tipsandtricks.html#AmIBundled
 static bool UncachedAmIBundled() {
@@ skipping 170 matching lines @@
         !it->compare(it->length() - kExtLength, kExtLength, kExt, kExtLength))
       return FilePath(bundle_name);
 
     // Separate this component from the next one.
     bundle_name += '/';
   }
 
   return FilePath();
 }
 
+#define TYPE_NAME_FOR_CF_TYPE_DEFN(TypeCF) \
+std::string TypeNameForCFType(TypeCF##Ref) { \
+  return #TypeCF; \
+}
+
+TYPE_NAME_FOR_CF_TYPE_DEFN(CFArray);
+TYPE_NAME_FOR_CF_TYPE_DEFN(CFBag);
+TYPE_NAME_FOR_CF_TYPE_DEFN(CFBoolean);
+TYPE_NAME_FOR_CF_TYPE_DEFN(CFData);
+TYPE_NAME_FOR_CF_TYPE_DEFN(CFDate);
+TYPE_NAME_FOR_CF_TYPE_DEFN(CFDictionary);
+TYPE_NAME_FOR_CF_TYPE_DEFN(CFNull);
+TYPE_NAME_FOR_CF_TYPE_DEFN(CFNumber);
+TYPE_NAME_FOR_CF_TYPE_DEFN(CFSet);
+TYPE_NAME_FOR_CF_TYPE_DEFN(CFString);
+
+#undef TYPE_NAME_FOR_CF_TYPE_DEFN
+
+std::string GetValueFromDictionaryErrorMessage(
+    CFStringRef key, const std::string& expected_type, CFTypeRef value) {
+  ScopedCFTypeRef<CFStringRef> actual_type_ref(
+      CFCopyTypeIDDescription(CFGetTypeID(value)));
+  return "Expected value for key " +
+      base::SysCFStringRefToUTF8(key) +
+      " to be " +
+      expected_type +
+      " but it was " +
+      base::SysCFStringRefToUTF8(actual_type_ref) +
+      " instead";
+}
+
 CFTypeRef GetValueFromDictionary(CFDictionaryRef dict,
                                  CFStringRef key,
                                  CFTypeID expected_type) {
   CFTypeRef value = CFDictionaryGetValue(dict, key);
   if (!value)
     return value;
 
   if (CFGetTypeID(value) != expected_type) {
-    ScopedCFTypeRef<CFStringRef> expected_type_ref(
+    std::string expected_type_name = base::SysCFStringRefToUTF8(
         CFCopyTypeIDDescription(expected_type));
-    ScopedCFTypeRef<CFStringRef> actual_type_ref(
-        CFCopyTypeIDDescription(CFGetTypeID(value)));
-    DLOG(WARNING) << "Expected value for key "
-                 << base::SysCFStringRefToUTF8(key)
-                 << " to be "
-                 << base::SysCFStringRefToUTF8(expected_type_ref)
-                 << " but it was "
-                 << base::SysCFStringRefToUTF8(actual_type_ref)
-                 << " instead";
+    DLOG(WARNING) << GetValueFromDictionaryErrorMessage(key,
+                                                        expected_type_name,
+                                                        value);
     return NULL;
   }
 
   return value;
 }
 
 void NSObjectRetain(void* obj) {
   id<NSObject> nsobj = static_cast<id<NSObject> >(obj);
   [nsobj retain];
 }
@@ skipping 79 matching lines @@
 CF_TO_NS_CAST_DEFN(CFLocale, NSLocale);
 CF_TO_NS_CAST_DEFN(CFNumber, NSNumber);
 CF_TO_NS_CAST_DEFN(CFRunLoopTimer, NSTimer);
 CF_TO_NS_CAST_DEFN(CFTimeZone, NSTimeZone);
 CF_TO_NS_MUTABLE_CAST_DEFN(Set);
 CF_TO_NS_CAST_DEFN(CFReadStream, NSInputStream);
 CF_TO_NS_CAST_DEFN(CFWriteStream, NSOutputStream);
 CF_TO_NS_MUTABLE_CAST_DEFN(String);
 CF_TO_NS_CAST_DEFN(CFURL, NSURL);
 
+#undef CF_TO_NS_CAST_DEFN
+#undef CF_TO_NS_MUTABLE_CAST_DEFN
+
 #define CF_CAST_DEFN(TypeCF) \
 template<> TypeCF##Ref \
 CFCast<TypeCF##Ref>(const CFTypeRef& cf_val) { \
   if (cf_val == NULL) { \
     return NULL; \
   } \
   if (CFGetTypeID(cf_val) == TypeCF##GetTypeID()) { \
     return reinterpret_cast<TypeCF##Ref>(cf_val); \
   } \
   return NULL; \
@@ skipping 10 matching lines @@
 CF_CAST_DEFN(CFBag);
 CF_CAST_DEFN(CFBoolean);
 CF_CAST_DEFN(CFData);
 CF_CAST_DEFN(CFDate);
 CF_CAST_DEFN(CFDictionary);
 CF_CAST_DEFN(CFNull);
 CF_CAST_DEFN(CFNumber);
 CF_CAST_DEFN(CFSet);
 CF_CAST_DEFN(CFString);
 
+#undef CF_CAST_DEFN
+
 }  // namespace mac
 }  // namespace base
 
 std::ostream& operator<<(std::ostream& o, const CFStringRef string) {
   return o << base::SysCFStringRefToUTF8(string);
 }
 
 std::ostream& operator<<(std::ostream& o, const CFErrorRef err) {
   base::mac::ScopedCFTypeRef<CFStringRef> desc(CFErrorCopyDescription(err));
   base::mac::ScopedCFTypeRef<CFDictionaryRef> user_info(
       CFErrorCopyUserInfo(err));
   CFStringRef errorDesc = NULL;
   if (user_info.get()) {
     errorDesc = reinterpret_cast<CFStringRef>(
         CFDictionaryGetValue(user_info.get(), kCFErrorDescriptionKey));
   }
   o << "Code: " << CFErrorGetCode(err)
     << " Domain: " << CFErrorGetDomain(err)
     << " Desc: " << desc.get();
   if(errorDesc) {
     o << "(" << errorDesc << ")";
   }
   return o;
 }