Use the new base::mac::GetValueFromDictionary<>() method.

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>
 
@@ skipping 95 matching lines @@
 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): Remove this function once all cases of it have been
-// replaced with the two-argument form below. See: crbug.com/104200.
-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
 // system.  In a traditional managed-memory environment, cf_object is
 // autoreleased and returned as an NSObject.  In a garbage-collected
 // environment, cf_object is marked as eligible for garbage collection.
 //
@@ skipping 96 matching lines @@
 // 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()));
+// CFTypeRef hello = CFSTR("hello world");
+// CFStringRef some_string = base::mac::CFCastStrict<CFStringRef>(hello);
 BASE_EXPORT template<typename T>
 T CFCast(const CFTypeRef& cf_val);
 
 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
@@ skipping 27 matching lines @@
 
 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__)
 
+// 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.
+// 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_