| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #include "base/mac/foundation_util.h" | |
| 6 | |
| 7 #include <stdlib.h> | |
| 8 #include <string.h> | |
| 9 | |
| 10 #include "base/files/file_path.h" | |
| 11 #include "base/logging.h" | |
| 12 #include "base/mac/bundle_locations.h" | |
| 13 #include "base/mac/mac_logging.h" | |
| 14 #include "base/strings/sys_string_conversions.h" | |
| 15 | |
| 16 #if !defined(OS_IOS) | |
| 17 extern "C" { | |
| 18 CFTypeID SecACLGetTypeID(); | |
| 19 CFTypeID SecTrustedApplicationGetTypeID(); | |
| 20 Boolean _CFIsObjC(CFTypeID typeID, CFTypeRef obj); | |
| 21 } // extern "C" | |
| 22 #endif | |
| 23 | |
| 24 namespace base { | |
| 25 namespace mac { | |
| 26 | |
| 27 namespace { | |
| 28 | |
| 29 bool g_cached_am_i_bundled_called = false; | |
| 30 bool g_cached_am_i_bundled_value = false; | |
| 31 bool g_override_am_i_bundled = false; | |
| 32 bool g_override_am_i_bundled_value = false; | |
| 33 | |
| 34 bool UncachedAmIBundled() { | |
| 35 #if defined(OS_IOS) | |
| 36 // All apps are bundled on iOS. | |
| 37 return true; | |
| 38 #else | |
| 39 if (g_override_am_i_bundled) | |
| 40 return g_override_am_i_bundled_value; | |
| 41 | |
| 42 // Yes, this is cheap. | |
| 43 return [[base::mac::OuterBundle() bundlePath] hasSuffix:@".app"]; | |
| 44 #endif | |
| 45 } | |
| 46 | |
| 47 } // namespace | |
| 48 | |
| 49 bool AmIBundled() { | |
| 50 // If the return value is not cached, this function will return different | |
| 51 // values depending on when it's called. This confuses some client code, see | |
| 52 // http://crbug.com/63183 . | |
| 53 if (!g_cached_am_i_bundled_called) { | |
| 54 g_cached_am_i_bundled_called = true; | |
| 55 g_cached_am_i_bundled_value = UncachedAmIBundled(); | |
| 56 } | |
| 57 DCHECK_EQ(g_cached_am_i_bundled_value, UncachedAmIBundled()) | |
| 58 << "The return value of AmIBundled() changed. This will confuse tests. " | |
| 59 << "Call SetAmIBundled() override manually if your test binary " | |
| 60 << "delay-loads the framework."; | |
| 61 return g_cached_am_i_bundled_value; | |
| 62 } | |
| 63 | |
| 64 void SetOverrideAmIBundled(bool value) { | |
| 65 #if defined(OS_IOS) | |
| 66 // It doesn't make sense not to be bundled on iOS. | |
| 67 if (!value) | |
| 68 NOTREACHED(); | |
| 69 #endif | |
| 70 g_override_am_i_bundled = true; | |
| 71 g_override_am_i_bundled_value = value; | |
| 72 } | |
| 73 | |
| 74 BASE_EXPORT void ClearAmIBundledCache() { | |
| 75 g_cached_am_i_bundled_called = false; | |
| 76 } | |
| 77 | |
| 78 bool IsBackgroundOnlyProcess() { | |
| 79 // This function really does want to examine NSBundle's idea of the main | |
| 80 // bundle dictionary. It needs to look at the actual running .app's | |
| 81 // Info.plist to access its LSUIElement property. | |
| 82 NSDictionary* info_dictionary = [base::mac::MainBundle() infoDictionary]; | |
| 83 return [[info_dictionary objectForKey:@"LSUIElement"] boolValue] != NO; | |
| 84 } | |
| 85 | |
| 86 FilePath PathForFrameworkBundleResource(CFStringRef resourceName) { | |
| 87 NSBundle* bundle = base::mac::FrameworkBundle(); | |
| 88 NSString* resourcePath = [bundle pathForResource:(NSString*)resourceName | |
| 89 ofType:nil]; | |
| 90 return NSStringToFilePath(resourcePath); | |
| 91 } | |
| 92 | |
| 93 OSType CreatorCodeForCFBundleRef(CFBundleRef bundle) { | |
| 94 OSType creator = kUnknownType; | |
| 95 CFBundleGetPackageInfo(bundle, NULL, &creator); | |
| 96 return creator; | |
| 97 } | |
| 98 | |
| 99 OSType CreatorCodeForApplication() { | |
| 100 CFBundleRef bundle = CFBundleGetMainBundle(); | |
| 101 if (!bundle) | |
| 102 return kUnknownType; | |
| 103 | |
| 104 return CreatorCodeForCFBundleRef(bundle); | |
| 105 } | |
| 106 | |
| 107 bool GetSearchPathDirectory(NSSearchPathDirectory directory, | |
| 108 NSSearchPathDomainMask domain_mask, | |
| 109 FilePath* result) { | |
| 110 DCHECK(result); | |
| 111 NSArray* dirs = | |
| 112 NSSearchPathForDirectoriesInDomains(directory, domain_mask, YES); | |
| 113 if ([dirs count] < 1) { | |
| 114 return false; | |
| 115 } | |
| 116 *result = NSStringToFilePath([dirs objectAtIndex:0]); | |
| 117 return true; | |
| 118 } | |
| 119 | |
| 120 bool GetLocalDirectory(NSSearchPathDirectory directory, FilePath* result) { | |
| 121 return GetSearchPathDirectory(directory, NSLocalDomainMask, result); | |
| 122 } | |
| 123 | |
| 124 bool GetUserDirectory(NSSearchPathDirectory directory, FilePath* result) { | |
| 125 return GetSearchPathDirectory(directory, NSUserDomainMask, result); | |
| 126 } | |
| 127 | |
| 128 FilePath GetUserLibraryPath() { | |
| 129 FilePath user_library_path; | |
| 130 if (!GetUserDirectory(NSLibraryDirectory, &user_library_path)) { | |
| 131 DLOG(WARNING) << "Could not get user library path"; | |
| 132 } | |
| 133 return user_library_path; | |
| 134 } | |
| 135 | |
| 136 // Takes a path to an (executable) binary and tries to provide the path to an | |
| 137 // application bundle containing it. It takes the outermost bundle that it can | |
| 138 // find (so for "/Foo/Bar.app/.../Baz.app/..." it produces "/Foo/Bar.app"). | |
| 139 // |exec_name| - path to the binary | |
| 140 // returns - path to the application bundle, or empty on error | |
| 141 FilePath GetAppBundlePath(const FilePath& exec_name) { | |
| 142 const char kExt[] = ".app"; | |
| 143 const size_t kExtLength = arraysize(kExt) - 1; | |
| 144 | |
| 145 // Split the path into components. | |
| 146 std::vector<std::string> components; | |
| 147 exec_name.GetComponents(&components); | |
| 148 | |
| 149 // It's an error if we don't get any components. | |
| 150 if (!components.size()) | |
| 151 return FilePath(); | |
| 152 | |
| 153 // Don't prepend '/' to the first component. | |
| 154 std::vector<std::string>::const_iterator it = components.begin(); | |
| 155 std::string bundle_name = *it; | |
| 156 DCHECK_GT(it->length(), 0U); | |
| 157 // If the first component ends in ".app", we're already done. | |
| 158 if (it->length() > kExtLength && | |
| 159 !it->compare(it->length() - kExtLength, kExtLength, kExt, kExtLength)) | |
| 160 return FilePath(bundle_name); | |
| 161 | |
| 162 // The first component may be "/" or "//", etc. Only append '/' if it doesn't | |
| 163 // already end in '/'. | |
| 164 if (bundle_name[bundle_name.length() - 1] != '/') | |
| 165 bundle_name += '/'; | |
| 166 | |
| 167 // Go through the remaining components. | |
| 168 for (++it; it != components.end(); ++it) { | |
| 169 DCHECK_GT(it->length(), 0U); | |
| 170 | |
| 171 bundle_name += *it; | |
| 172 | |
| 173 // If the current component ends in ".app", we're done. | |
| 174 if (it->length() > kExtLength && | |
| 175 !it->compare(it->length() - kExtLength, kExtLength, kExt, kExtLength)) | |
| 176 return FilePath(bundle_name); | |
| 177 | |
| 178 // Separate this component from the next one. | |
| 179 bundle_name += '/'; | |
| 180 } | |
| 181 | |
| 182 return FilePath(); | |
| 183 } | |
| 184 | |
| 185 #define TYPE_NAME_FOR_CF_TYPE_DEFN(TypeCF) \ | |
| 186 std::string TypeNameForCFType(TypeCF##Ref) { \ | |
| 187 return #TypeCF; \ | |
| 188 } | |
| 189 | |
| 190 TYPE_NAME_FOR_CF_TYPE_DEFN(CFArray); | |
| 191 TYPE_NAME_FOR_CF_TYPE_DEFN(CFBag); | |
| 192 TYPE_NAME_FOR_CF_TYPE_DEFN(CFBoolean); | |
| 193 TYPE_NAME_FOR_CF_TYPE_DEFN(CFData); | |
| 194 TYPE_NAME_FOR_CF_TYPE_DEFN(CFDate); | |
| 195 TYPE_NAME_FOR_CF_TYPE_DEFN(CFDictionary); | |
| 196 TYPE_NAME_FOR_CF_TYPE_DEFN(CFNull); | |
| 197 TYPE_NAME_FOR_CF_TYPE_DEFN(CFNumber); | |
| 198 TYPE_NAME_FOR_CF_TYPE_DEFN(CFSet); | |
| 199 TYPE_NAME_FOR_CF_TYPE_DEFN(CFString); | |
| 200 TYPE_NAME_FOR_CF_TYPE_DEFN(CFURL); | |
| 201 TYPE_NAME_FOR_CF_TYPE_DEFN(CFUUID); | |
| 202 | |
| 203 TYPE_NAME_FOR_CF_TYPE_DEFN(CGColor); | |
| 204 | |
| 205 TYPE_NAME_FOR_CF_TYPE_DEFN(CTFont); | |
| 206 TYPE_NAME_FOR_CF_TYPE_DEFN(CTRun); | |
| 207 | |
| 208 #undef TYPE_NAME_FOR_CF_TYPE_DEFN | |
| 209 | |
| 210 void NSObjectRetain(void* obj) { | |
| 211 id<NSObject> nsobj = static_cast<id<NSObject> >(obj); | |
| 212 [nsobj retain]; | |
| 213 } | |
| 214 | |
| 215 void NSObjectRelease(void* obj) { | |
| 216 id<NSObject> nsobj = static_cast<id<NSObject> >(obj); | |
| 217 [nsobj release]; | |
| 218 } | |
| 219 | |
| 220 void* CFTypeRefToNSObjectAutorelease(CFTypeRef cf_object) { | |
| 221 // When GC is on, NSMakeCollectable marks cf_object for GC and autorelease | |
| 222 // is a no-op. | |
| 223 // | |
| 224 // In the traditional GC-less environment, NSMakeCollectable is a no-op, | |
| 225 // and cf_object is autoreleased, balancing out the caller's ownership claim. | |
| 226 // | |
| 227 // NSMakeCollectable returns nil when used on a NULL object. | |
| 228 return [NSMakeCollectable(cf_object) autorelease]; | |
| 229 } | |
| 230 | |
| 231 static const char* base_bundle_id; | |
| 232 | |
| 233 const char* BaseBundleID() { | |
| 234 if (base_bundle_id) { | |
| 235 return base_bundle_id; | |
| 236 } | |
| 237 | |
| 238 #if defined(GOOGLE_CHROME_BUILD) | |
| 239 return "com.google.Chrome"; | |
| 240 #else | |
| 241 return "org.chromium.Chromium"; | |
| 242 #endif | |
| 243 } | |
| 244 | |
| 245 void SetBaseBundleID(const char* new_base_bundle_id) { | |
| 246 if (new_base_bundle_id != base_bundle_id) { | |
| 247 free((void*)base_bundle_id); | |
| 248 base_bundle_id = new_base_bundle_id ? strdup(new_base_bundle_id) : NULL; | |
| 249 } | |
| 250 } | |
| 251 | |
| 252 // Definitions for the corresponding CF_TO_NS_CAST_DECL macros in | |
| 253 // foundation_util.h. | |
| 254 #define CF_TO_NS_CAST_DEFN(TypeCF, TypeNS) \ | |
| 255 \ | |
| 256 TypeNS* CFToNSCast(TypeCF##Ref cf_val) { \ | |
| 257 DCHECK(!cf_val || TypeCF##GetTypeID() == CFGetTypeID(cf_val)); \ | |
| 258 TypeNS* ns_val = \ | |
| 259 const_cast<TypeNS*>(reinterpret_cast<const TypeNS*>(cf_val)); \ | |
| 260 return ns_val; \ | |
| 261 } \ | |
| 262 \ | |
| 263 TypeCF##Ref NSToCFCast(TypeNS* ns_val) { \ | |
| 264 TypeCF##Ref cf_val = reinterpret_cast<TypeCF##Ref>(ns_val); \ | |
| 265 DCHECK(!cf_val || TypeCF##GetTypeID() == CFGetTypeID(cf_val)); \ | |
| 266 return cf_val; \ | |
| 267 } | |
| 268 | |
| 269 #define CF_TO_NS_MUTABLE_CAST_DEFN(name) \ | |
| 270 CF_TO_NS_CAST_DEFN(CF##name, NS##name) \ | |
| 271 \ | |
| 272 NSMutable##name* CFToNSCast(CFMutable##name##Ref cf_val) { \ | |
| 273 DCHECK(!cf_val || CF##name##GetTypeID() == CFGetTypeID(cf_val)); \ | |
| 274 NSMutable##name* ns_val = reinterpret_cast<NSMutable##name*>(cf_val); \ | |
| 275 return ns_val; \ | |
| 276 } \ | |
| 277 \ | |
| 278 CFMutable##name##Ref NSToCFCast(NSMutable##name* ns_val) { \ | |
| 279 CFMutable##name##Ref cf_val = \ | |
| 280 reinterpret_cast<CFMutable##name##Ref>(ns_val); \ | |
| 281 DCHECK(!cf_val || CF##name##GetTypeID() == CFGetTypeID(cf_val)); \ | |
| 282 return cf_val; \ | |
| 283 } | |
| 284 | |
| 285 CF_TO_NS_MUTABLE_CAST_DEFN(Array); | |
| 286 CF_TO_NS_MUTABLE_CAST_DEFN(AttributedString); | |
| 287 CF_TO_NS_CAST_DEFN(CFCalendar, NSCalendar); | |
| 288 CF_TO_NS_MUTABLE_CAST_DEFN(CharacterSet); | |
| 289 CF_TO_NS_MUTABLE_CAST_DEFN(Data); | |
| 290 CF_TO_NS_CAST_DEFN(CFDate, NSDate); | |
| 291 CF_TO_NS_MUTABLE_CAST_DEFN(Dictionary); | |
| 292 CF_TO_NS_CAST_DEFN(CFError, NSError); | |
| 293 CF_TO_NS_CAST_DEFN(CFLocale, NSLocale); | |
| 294 CF_TO_NS_CAST_DEFN(CFNumber, NSNumber); | |
| 295 CF_TO_NS_CAST_DEFN(CFRunLoopTimer, NSTimer); | |
| 296 CF_TO_NS_CAST_DEFN(CFTimeZone, NSTimeZone); | |
| 297 CF_TO_NS_MUTABLE_CAST_DEFN(Set); | |
| 298 CF_TO_NS_CAST_DEFN(CFReadStream, NSInputStream); | |
| 299 CF_TO_NS_CAST_DEFN(CFWriteStream, NSOutputStream); | |
| 300 CF_TO_NS_MUTABLE_CAST_DEFN(String); | |
| 301 CF_TO_NS_CAST_DEFN(CFURL, NSURL); | |
| 302 | |
| 303 #if defined(OS_IOS) | |
| 304 CF_TO_NS_CAST_DEFN(CTFont, UIFont); | |
| 305 #else | |
| 306 // The NSFont/CTFont toll-free bridging is broken when it comes to type | |
| 307 // checking, so do some special-casing. | |
| 308 // http://www.openradar.me/15341349 rdar://15341349 | |
| 309 NSFont* CFToNSCast(CTFontRef cf_val) { | |
| 310 NSFont* ns_val = | |
| 311 const_cast<NSFont*>(reinterpret_cast<const NSFont*>(cf_val)); | |
| 312 DCHECK(!cf_val || | |
| 313 CTFontGetTypeID() == CFGetTypeID(cf_val) || | |
| 314 (_CFIsObjC(CTFontGetTypeID(), cf_val) && | |
| 315 [ns_val isKindOfClass:NSClassFromString(@"NSFont")])); | |
| 316 return ns_val; | |
| 317 } | |
| 318 | |
| 319 CTFontRef NSToCFCast(NSFont* ns_val) { | |
| 320 CTFontRef cf_val = reinterpret_cast<CTFontRef>(ns_val); | |
| 321 DCHECK(!cf_val || | |
| 322 CTFontGetTypeID() == CFGetTypeID(cf_val) || | |
| 323 [ns_val isKindOfClass:NSClassFromString(@"NSFont")]); | |
| 324 return cf_val; | |
| 325 } | |
| 326 #endif | |
| 327 | |
| 328 #undef CF_TO_NS_CAST_DEFN | |
| 329 #undef CF_TO_NS_MUTABLE_CAST_DEFN | |
| 330 | |
| 331 #define CF_CAST_DEFN(TypeCF) \ | |
| 332 template<> TypeCF##Ref \ | |
| 333 CFCast<TypeCF##Ref>(const CFTypeRef& cf_val) { \ | |
| 334 if (cf_val == NULL) { \ | |
| 335 return NULL; \ | |
| 336 } \ | |
| 337 if (CFGetTypeID(cf_val) == TypeCF##GetTypeID()) { \ | |
| 338 return (TypeCF##Ref)(cf_val); \ | |
| 339 } \ | |
| 340 return NULL; \ | |
| 341 } \ | |
| 342 \ | |
| 343 template<> TypeCF##Ref \ | |
| 344 CFCastStrict<TypeCF##Ref>(const CFTypeRef& cf_val) { \ | |
| 345 TypeCF##Ref rv = CFCast<TypeCF##Ref>(cf_val); \ | |
| 346 DCHECK(cf_val == NULL || rv); \ | |
| 347 return rv; \ | |
| 348 } | |
| 349 | |
| 350 CF_CAST_DEFN(CFArray); | |
| 351 CF_CAST_DEFN(CFBag); | |
| 352 CF_CAST_DEFN(CFBoolean); | |
| 353 CF_CAST_DEFN(CFData); | |
| 354 CF_CAST_DEFN(CFDate); | |
| 355 CF_CAST_DEFN(CFDictionary); | |
| 356 CF_CAST_DEFN(CFNull); | |
| 357 CF_CAST_DEFN(CFNumber); | |
| 358 CF_CAST_DEFN(CFSet); | |
| 359 CF_CAST_DEFN(CFString); | |
| 360 CF_CAST_DEFN(CFURL); | |
| 361 CF_CAST_DEFN(CFUUID); | |
| 362 | |
| 363 CF_CAST_DEFN(CGColor); | |
| 364 | |
| 365 CF_CAST_DEFN(CTFontDescriptor); | |
| 366 CF_CAST_DEFN(CTRun); | |
| 367 | |
| 368 #if defined(OS_IOS) | |
| 369 CF_CAST_DEFN(CTFont); | |
| 370 #else | |
| 371 // The NSFont/CTFont toll-free bridging is broken when it comes to type | |
| 372 // checking, so do some special-casing. | |
| 373 // http://www.openradar.me/15341349 rdar://15341349 | |
| 374 template<> CTFontRef | |
| 375 CFCast<CTFontRef>(const CFTypeRef& cf_val) { | |
| 376 if (cf_val == NULL) { | |
| 377 return NULL; | |
| 378 } | |
| 379 if (CFGetTypeID(cf_val) == CTFontGetTypeID()) { | |
| 380 return (CTFontRef)(cf_val); | |
| 381 } | |
| 382 | |
| 383 if (!_CFIsObjC(CTFontGetTypeID(), cf_val)) | |
| 384 return NULL; | |
| 385 | |
| 386 id<NSObject> ns_val = reinterpret_cast<id>(const_cast<void*>(cf_val)); | |
| 387 if ([ns_val isKindOfClass:NSClassFromString(@"NSFont")]) { | |
| 388 return (CTFontRef)(cf_val); | |
| 389 } | |
| 390 return NULL; | |
| 391 } | |
| 392 | |
| 393 template<> CTFontRef | |
| 394 CFCastStrict<CTFontRef>(const CFTypeRef& cf_val) { | |
| 395 CTFontRef rv = CFCast<CTFontRef>(cf_val); | |
| 396 DCHECK(cf_val == NULL || rv); | |
| 397 return rv; | |
| 398 } | |
| 399 #endif | |
| 400 | |
| 401 #if !defined(OS_IOS) | |
| 402 CF_CAST_DEFN(SecACL); | |
| 403 CF_CAST_DEFN(SecTrustedApplication); | |
| 404 #endif | |
| 405 | |
| 406 #undef CF_CAST_DEFN | |
| 407 | |
| 408 std::string GetValueFromDictionaryErrorMessage( | |
| 409 CFStringRef key, const std::string& expected_type, CFTypeRef value) { | |
| 410 ScopedCFTypeRef<CFStringRef> actual_type_ref( | |
| 411 CFCopyTypeIDDescription(CFGetTypeID(value))); | |
| 412 return "Expected value for key " + | |
| 413 base::SysCFStringRefToUTF8(key) + | |
| 414 " to be " + | |
| 415 expected_type + | |
| 416 " but it was " + | |
| 417 base::SysCFStringRefToUTF8(actual_type_ref) + | |
| 418 " instead"; | |
| 419 } | |
| 420 | |
| 421 NSString* FilePathToNSString(const FilePath& path) { | |
| 422 if (path.empty()) | |
| 423 return nil; | |
| 424 return [NSString stringWithUTF8String:path.value().c_str()]; | |
| 425 } | |
| 426 | |
| 427 FilePath NSStringToFilePath(NSString* str) { | |
| 428 if (![str length]) | |
| 429 return FilePath(); | |
| 430 return FilePath([str fileSystemRepresentation]); | |
| 431 } | |
| 432 | |
| 433 } // namespace mac | |
| 434 } // namespace base | |
| 435 | |
| 436 std::ostream& operator<<(std::ostream& o, const CFStringRef string) { | |
| 437 return o << base::SysCFStringRefToUTF8(string); | |
| 438 } | |
| 439 | |
| 440 std::ostream& operator<<(std::ostream& o, const CFErrorRef err) { | |
| 441 base::ScopedCFTypeRef<CFStringRef> desc(CFErrorCopyDescription(err)); | |
| 442 base::ScopedCFTypeRef<CFDictionaryRef> user_info(CFErrorCopyUserInfo(err)); | |
| 443 CFStringRef errorDesc = NULL; | |
| 444 if (user_info.get()) { | |
| 445 errorDesc = reinterpret_cast<CFStringRef>( | |
| 446 CFDictionaryGetValue(user_info.get(), kCFErrorDescriptionKey)); | |
| 447 } | |
| 448 o << "Code: " << CFErrorGetCode(err) | |
| 449 << " Domain: " << CFErrorGetDomain(err) | |
| 450 << " Desc: " << desc.get(); | |
| 451 if(errorDesc) { | |
| 452 o << "(" << errorDesc << ")"; | |
| 453 } | |
| 454 return o; | |
| 455 } | |
| OLD | NEW |
|---|
Chromium Code Reviews
