base/mac/mac_util.mm

   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/mac_util.h"
   6
   7 #import <Cocoa/Cocoa.h>
   8 #import <IOKit/IOKitLib.h>
   9
  10 #include <errno.h>
  11 #include <string.h>
  12 #include <sys/utsname.h>
  13 #include <sys/xattr.h>
  14
  15 #include "base/files/file_path.h"
  16 #include "base/logging.h"
  17 #include "base/mac/bundle_locations.h"
  18 #include "base/mac/foundation_util.h"
  19 #include "base/mac/mac_logging.h"
  20 #include "base/mac/scoped_cftyperef.h"
  21 #include "base/mac/scoped_ioobject.h"
  22 #include "base/mac/scoped_nsobject.h"
  23 #include "base/mac/sdk_forward_declarations.h"
  24 #include "base/strings/string_number_conversions.h"
  25 #include "base/strings/string_piece.h"
  26 #include "base/strings/sys_string_conversions.h"
  27
  28 namespace base {
  29 namespace mac {
  30
  31 namespace {
  32
  33 // The current count of outstanding requests for full screen mode from browser
  34 // windows, plugins, etc.
  35 int g_full_screen_requests[kNumFullScreenModes] = { 0 };
  36
  37 // Sets the appropriate application presentation option based on the current
  38 // full screen requests.  Since only one presentation option can be active at a
  39 // given time, full screen requests are ordered by priority.  If there are no
  40 // outstanding full screen requests, reverts to normal mode.  If the correct
  41 // presentation option is already set, does nothing.
  42 void SetUIMode() {
  43   NSApplicationPresentationOptions current_options =
  44       [NSApp presentationOptions];
  45
  46   // Determine which mode should be active, based on which requests are
  47   // currently outstanding.  More permissive requests take precedence.  For
  48   // example, plugins request |kFullScreenModeAutoHideAll|, while browser
  49   // windows request |kFullScreenModeHideDock| when the fullscreen overlay is
  50   // down.  Precedence goes to plugins in this case, so AutoHideAll wins over
  51   // HideDock.
  52   NSApplicationPresentationOptions desired_options =
  53       NSApplicationPresentationDefault;
  54   if (g_full_screen_requests[kFullScreenModeAutoHideAll] > 0) {
  55     desired_options = NSApplicationPresentationHideDock |
  56                       NSApplicationPresentationAutoHideMenuBar;
  57   } else if (g_full_screen_requests[kFullScreenModeHideDock] > 0) {
  58     desired_options = NSApplicationPresentationHideDock;
  59   } else if (g_full_screen_requests[kFullScreenModeHideAll] > 0) {
  60     desired_options = NSApplicationPresentationHideDock |
  61                       NSApplicationPresentationHideMenuBar;
  62   }
  63
  64   // Mac OS X bug: if the window is fullscreened (Lion-style) and
  65   // NSApplicationPresentationDefault is requested, the result is that the menu
  66   // bar doesn't auto-hide. rdar://13576498 http://www.openradar.me/13576498
  67   //
  68   // As a workaround, in that case, explicitly set the presentation options to
  69   // the ones that are set by the system as it fullscreens a window.
  70   if (desired_options == NSApplicationPresentationDefault &&
  71       current_options & NSApplicationPresentationFullScreen) {
  72     desired_options |= NSApplicationPresentationFullScreen |
  73                        NSApplicationPresentationAutoHideMenuBar |
  74                        NSApplicationPresentationAutoHideDock;
  75   }
  76
  77   if (current_options != desired_options)
  78     [NSApp setPresentationOptions:desired_options];
  79 }
  80
  81 // Looks into Shared File Lists corresponding to Login Items for the item
  82 // representing the current application.  If such an item is found, returns a
  83 // retained reference to it. Caller is responsible for releasing the reference.
  84 LSSharedFileListItemRef GetLoginItemForApp() {
  85   ScopedCFTypeRef<LSSharedFileListRef> login_items(LSSharedFileListCreate(
  86       NULL, kLSSharedFileListSessionLoginItems, NULL));
  87
  88   if (!login_items.get()) {
  89     DLOG(ERROR) << "Couldn't get a Login Items list.";
  90     return NULL;
  91   }
  92
  93   base::scoped_nsobject<NSArray> login_items_array(
  94       CFToNSCast(LSSharedFileListCopySnapshot(login_items, NULL)));
  95
  96   NSURL* url = [NSURL fileURLWithPath:[base::mac::MainBundle() bundlePath]];
  97
  98   for(NSUInteger i = 0; i < [login_items_array count]; ++i) {
  99     LSSharedFileListItemRef item = reinterpret_cast<LSSharedFileListItemRef>(
 100         [login_items_array objectAtIndex:i]);
 101     CFURLRef item_url_ref = NULL;
 102
 103     if (LSSharedFileListItemResolve(item, 0, &item_url_ref, NULL) == noErr) {
 104       ScopedCFTypeRef<CFURLRef> item_url(item_url_ref);
 105       if (CFEqual(item_url, url)) {
 106         CFRetain(item);
 107         return item;
 108       }
 109     }
 110   }
 111
 112   return NULL;
 113 }
 114
 115 bool IsHiddenLoginItem(LSSharedFileListItemRef item) {
 116   ScopedCFTypeRef<CFBooleanRef> hidden(reinterpret_cast<CFBooleanRef>(
 117       LSSharedFileListItemCopyProperty(item,
 118           reinterpret_cast<CFStringRef>(kLSSharedFileListLoginItemHidden))));
 119
 120   return hidden && hidden == kCFBooleanTrue;
 121 }
 122
 123 }  // namespace
 124
 125 std::string PathFromFSRef(const FSRef& ref) {
 126   ScopedCFTypeRef<CFURLRef> url(
 127       CFURLCreateFromFSRef(kCFAllocatorDefault, &ref));
 128   NSString *path_string = [(NSURL *)url.get() path];
 129   return [path_string fileSystemRepresentation];
 130 }
 131
 132 bool FSRefFromPath(const std::string& path, FSRef* ref) {
 133   OSStatus status = FSPathMakeRef((const UInt8*)path.c_str(),
 134                                   ref, nil);
 135   return status == noErr;
 136 }
 137
 138 CGColorSpaceRef GetGenericRGBColorSpace() {
 139   // Leaked. That's OK, it's scoped to the lifetime of the application.
 140   static CGColorSpaceRef g_color_space_generic_rgb(
 141       CGColorSpaceCreateWithName(kCGColorSpaceGenericRGB));
 142   DLOG_IF(ERROR, !g_color_space_generic_rgb) <<
 143       "Couldn't get the generic RGB color space";
 144   return g_color_space_generic_rgb;
 145 }
 146
 147 CGColorSpaceRef GetSRGBColorSpace() {
 148   // Leaked.  That's OK, it's scoped to the lifetime of the application.
 149   static CGColorSpaceRef g_color_space_sRGB =
 150       CGColorSpaceCreateWithName(kCGColorSpaceSRGB);
 151   DLOG_IF(ERROR, !g_color_space_sRGB) << "Couldn't get the sRGB color space";
 152   return g_color_space_sRGB;
 153 }
 154
 155 CGColorSpaceRef GetSystemColorSpace() {
 156   // Leaked.  That's OK, it's scoped to the lifetime of the application.
 157   // Try to get the main display's color space.
 158   static CGColorSpaceRef g_system_color_space =
 159       CGDisplayCopyColorSpace(CGMainDisplayID());
 160
 161   if (!g_system_color_space) {
 162     // Use a generic RGB color space.  This is better than nothing.
 163     g_system_color_space = CGColorSpaceCreateDeviceRGB();
 164
 165     if (g_system_color_space) {
 166       DLOG(WARNING) <<
 167           "Couldn't get the main display's color space, using generic";
 168     } else {
 169       DLOG(ERROR) << "Couldn't get any color space";
 170     }
 171   }
 172
 173   return g_system_color_space;
 174 }
 175
 176 // Add a request for full screen mode.  Must be called on the main thread.
 177 void RequestFullScreen(FullScreenMode mode) {
 178   DCHECK_LT(mode, kNumFullScreenModes);
 179   if (mode >= kNumFullScreenModes)
 180     return;
 181
 182   DCHECK_GE(g_full_screen_requests[mode], 0);
 183   if (mode < 0)
 184     return;
 185
 186   g_full_screen_requests[mode] = std::max(g_full_screen_requests[mode] + 1, 1);
 187   SetUIMode();
 188 }
 189
 190 // Release a request for full screen mode.  Must be called on the main thread.
 191 void ReleaseFullScreen(FullScreenMode mode) {
 192   DCHECK_LT(mode, kNumFullScreenModes);
 193   if (mode >= kNumFullScreenModes)
 194     return;
 195
 196   DCHECK_GE(g_full_screen_requests[mode], 0);
 197   if (mode < 0)
 198     return;
 199
 200   g_full_screen_requests[mode] = std::max(g_full_screen_requests[mode] - 1, 0);
 201   SetUIMode();
 202 }
 203
 204 // Switches full screen modes.  Releases a request for |from_mode| and adds a
 205 // new request for |to_mode|.  Must be called on the main thread.
 206 void SwitchFullScreenModes(FullScreenMode from_mode, FullScreenMode to_mode) {
 207   DCHECK_LT(from_mode, kNumFullScreenModes);
 208   DCHECK_LT(to_mode, kNumFullScreenModes);
 209   if (from_mode >= kNumFullScreenModes || to_mode >= kNumFullScreenModes)
 210     return;
 211
 212   DCHECK_GT(g_full_screen_requests[from_mode], 0);
 213   DCHECK_GE(g_full_screen_requests[to_mode], 0);
 214   g_full_screen_requests[from_mode] =
 215       std::max(g_full_screen_requests[from_mode] - 1, 0);
 216   g_full_screen_requests[to_mode] =
 217       std::max(g_full_screen_requests[to_mode] + 1, 1);
 218   SetUIMode();
 219 }
 220
 221 void SetCursorVisibility(bool visible) {
 222   if (visible)
 223     [NSCursor unhide];
 224   else
 225     [NSCursor hide];
 226 }
 227
 228 bool ShouldWindowsMiniaturizeOnDoubleClick() {
 229   // We use an undocumented method in Cocoa; if it doesn't exist, default to
 230   // |true|. If it ever goes away, we can do (using an undocumented pref key):
 231   //   NSUserDefaults* defaults = [NSUserDefaults standardUserDefaults];
 232   //   return ![defaults objectForKey:@"AppleMiniaturizeOnDoubleClick"] ||
 233   //          [defaults boolForKey:@"AppleMiniaturizeOnDoubleClick"];
 234   BOOL methodImplemented =
 235       [NSWindow respondsToSelector:@selector(_shouldMiniaturizeOnDoubleClick)];
 236   DCHECK(methodImplemented);
 237   return !methodImplemented ||
 238       [NSWindow performSelector:@selector(_shouldMiniaturizeOnDoubleClick)];
 239 }
 240
 241 void ActivateProcess(pid_t pid) {
 242   ProcessSerialNumber process;
 243   OSStatus status = GetProcessForPID(pid, &process);
 244   if (status == noErr) {
 245     SetFrontProcess(&process);
 246   } else {
 247     OSSTATUS_DLOG(WARNING, status) << "Unable to get process for pid " << pid;
 248   }
 249 }
 250
 251 bool AmIForeground() {
 252   ProcessSerialNumber foreground_psn = { 0 };
 253   OSErr err = GetFrontProcess(&foreground_psn);
 254   if (err != noErr) {
 255     OSSTATUS_DLOG(WARNING, err) << "GetFrontProcess";
 256     return false;
 257   }
 258
 259   ProcessSerialNumber my_psn = { 0, kCurrentProcess };
 260
 261   Boolean result = FALSE;
 262   err = SameProcess(&foreground_psn, &my_psn, &result);
 263   if (err != noErr) {
 264     OSSTATUS_DLOG(WARNING, err) << "SameProcess";
 265     return false;
 266   }
 267
 268   return result;
 269 }
 270
 271 bool SetFileBackupExclusion(const FilePath& file_path) {
 272   NSString* file_path_ns =
 273       [NSString stringWithUTF8String:file_path.value().c_str()];
 274   NSURL* file_url = [NSURL fileURLWithPath:file_path_ns];
 275
 276   // When excludeByPath is true the application must be running with root
 277   // privileges (admin for 10.6 and earlier) but the URL does not have to
 278   // already exist. When excludeByPath is false the URL must already exist but
 279   // can be used in non-root (or admin as above) mode. We use false so that
 280   // non-root (or admin) users don't get their TimeMachine drive filled up with
 281   // unnecessary backups.
 282   OSStatus os_err =
 283       CSBackupSetItemExcluded(base::mac::NSToCFCast(file_url), TRUE, FALSE);
 284   if (os_err != noErr) {
 285     OSSTATUS_DLOG(WARNING, os_err)
 286         << "Failed to set backup exclusion for file '"
 287         << file_path.value().c_str() << "'";
 288   }
 289   return os_err == noErr;
 290 }
 291
 292 bool CheckLoginItemStatus(bool* is_hidden) {
 293   ScopedCFTypeRef<LSSharedFileListItemRef> item(GetLoginItemForApp());
 294   if (!item.get())
 295     return false;
 296
 297   if (is_hidden)
 298     *is_hidden = IsHiddenLoginItem(item);
 299
 300   return true;
 301 }
 302
 303 void AddToLoginItems(bool hide_on_startup) {
 304   ScopedCFTypeRef<LSSharedFileListItemRef> item(GetLoginItemForApp());
 305   if (item.get() && (IsHiddenLoginItem(item) == hide_on_startup)) {
 306     return;  // Already is a login item with required hide flag.
 307   }
 308
 309   ScopedCFTypeRef<LSSharedFileListRef> login_items(LSSharedFileListCreate(
 310       NULL, kLSSharedFileListSessionLoginItems, NULL));
 311
 312   if (!login_items.get()) {
 313     DLOG(ERROR) << "Couldn't get a Login Items list.";
 314     return;
 315   }
 316
 317   // Remove the old item, it has wrong hide flag, we'll create a new one.
 318   if (item.get()) {
 319     LSSharedFileListItemRemove(login_items, item);
 320   }
 321
 322   NSURL* url = [NSURL fileURLWithPath:[base::mac::MainBundle() bundlePath]];
 323
 324   BOOL hide = hide_on_startup ? YES : NO;
 325   NSDictionary* properties =
 326       [NSDictionary
 327         dictionaryWithObject:[NSNumber numberWithBool:hide]
 328                       forKey:(NSString*)kLSSharedFileListLoginItemHidden];
 329
 330   ScopedCFTypeRef<LSSharedFileListItemRef> new_item;
 331   new_item.reset(LSSharedFileListInsertItemURL(
 332       login_items, kLSSharedFileListItemLast, NULL, NULL,
 333       reinterpret_cast<CFURLRef>(url),
 334       reinterpret_cast<CFDictionaryRef>(properties), NULL));
 335
 336   if (!new_item.get()) {
 337     DLOG(ERROR) << "Couldn't insert current app into Login Items list.";
 338   }
 339 }
 340
 341 void RemoveFromLoginItems() {
 342   ScopedCFTypeRef<LSSharedFileListItemRef> item(GetLoginItemForApp());
 343   if (!item.get())
 344     return;
 345
 346   ScopedCFTypeRef<LSSharedFileListRef> login_items(LSSharedFileListCreate(
 347       NULL, kLSSharedFileListSessionLoginItems, NULL));
 348
 349   if (!login_items.get()) {
 350     DLOG(ERROR) << "Couldn't get a Login Items list.";
 351     return;
 352   }
 353
 354   LSSharedFileListItemRemove(login_items, item);
 355 }
 356
 357 bool WasLaunchedAsLoginOrResumeItem() {
 358   ProcessSerialNumber psn = { 0, kCurrentProcess };
 359   ProcessInfoRec info = {};
 360   info.processInfoLength = sizeof(info);
 361
 362   if (GetProcessInformation(&psn, &info) == noErr) {
 363     ProcessInfoRec parent_info = {};
 364     parent_info.processInfoLength = sizeof(parent_info);
 365     if (GetProcessInformation(&info.processLauncher, &parent_info) == noErr)
 366       return parent_info.processSignature == 'lgnw';
 367   }
 368   return false;
 369 }
 370
 371 bool WasLaunchedAsLoginItemRestoreState() {
 372   // "Reopen windows..." option was added for Lion.  Prior OS versions should
 373   // not have this behavior.
 374   if (IsOSSnowLeopard() || !WasLaunchedAsLoginOrResumeItem())
 375     return false;
 376
 377   CFStringRef app = CFSTR("com.apple.loginwindow");
 378   CFStringRef save_state = CFSTR("TALLogoutSavesState");
 379   ScopedCFTypeRef<CFPropertyListRef> plist(
 380       CFPreferencesCopyAppValue(save_state, app));
 381   // According to documentation, com.apple.loginwindow.plist does not exist on a
 382   // fresh installation until the user changes a login window setting.  The
 383   // "reopen windows" option is checked by default, so the plist would exist had
 384   // the user unchecked it.
 385   // https://developer.apple.com/library/mac/documentation/macosx/conceptual/bpsystemstartup/chapters/CustomLogin.html
 386   if (!plist)
 387     return true;
 388
 389   if (CFBooleanRef restore_state = base::mac::CFCast<CFBooleanRef>(plist))
 390     return CFBooleanGetValue(restore_state);
 391
 392   return false;
 393 }
 394
 395 bool WasLaunchedAsHiddenLoginItem() {
 396   if (!WasLaunchedAsLoginOrResumeItem())
 397     return false;
 398
 399   ScopedCFTypeRef<LSSharedFileListItemRef> item(GetLoginItemForApp());
 400   if (!item.get()) {
 401     // Lion can launch items for the resume feature.  So log an error only for
 402     // Snow Leopard or earlier.
 403     if (IsOSSnowLeopard())
 404       DLOG(ERROR) <<
 405           "Process launched at Login but can't access Login Item List.";
 406
 407     return false;
 408   }
 409   return IsHiddenLoginItem(item);
 410 }
 411
 412 bool RemoveQuarantineAttribute(const FilePath& file_path) {
 413   const char kQuarantineAttrName[] = "com.apple.quarantine";
 414   int status = removexattr(file_path.value().c_str(), kQuarantineAttrName, 0);
 415   return status == 0 || errno == ENOATTR;
 416 }
 417
 418 namespace {
 419
 420 // Returns the running system's Darwin major version. Don't call this, it's
 421 // an implementation detail and its result is meant to be cached by
 422 // MacOSXMinorVersion.
 423 int DarwinMajorVersionInternal() {
 424   // base::OperatingSystemVersionNumbers calls Gestalt, which is a
 425   // higher-level operation than is needed. It might perform unnecessary
 426   // operations. On 10.6, it was observed to be able to spawn threads (see
 427   // http://crbug.com/53200). It might also read files or perform other
 428   // blocking operations. Actually, nobody really knows for sure just what
 429   // Gestalt might do, or what it might be taught to do in the future.
 430   //
 431   // uname, on the other hand, is implemented as a simple series of sysctl
 432   // system calls to obtain the relevant data from the kernel. The data is
 433   // compiled right into the kernel, so no threads or blocking or other
 434   // funny business is necessary.
 435
 436   struct utsname uname_info;
 437   if (uname(&uname_info) != 0) {
 438     DPLOG(ERROR) << "uname";
 439     return 0;
 440   }
 441
 442   if (strcmp(uname_info.sysname, "Darwin") != 0) {
 443     DLOG(ERROR) << "unexpected uname sysname " << uname_info.sysname;
 444     return 0;
 445   }
 446
 447   int darwin_major_version = 0;
 448   char* dot = strchr(uname_info.release, '.');
 449   if (dot) {
 450     if (!base::StringToInt(base::StringPiece(uname_info.release,
 451                                              dot - uname_info.release),
 452                            &darwin_major_version)) {
 453       dot = NULL;
 454     }
 455   }
 456
 457   if (!dot) {
 458     DLOG(ERROR) << "could not parse uname release " << uname_info.release;
 459     return 0;
 460   }
 461
 462   return darwin_major_version;
 463 }
 464
 465 // Returns the running system's Mac OS X minor version. This is the |y| value
 466 // in 10.y or 10.y.z. Don't call this, it's an implementation detail and the
 467 // result is meant to be cached by MacOSXMinorVersion.
 468 int MacOSXMinorVersionInternal() {
 469   int darwin_major_version = DarwinMajorVersionInternal();
 470
 471   // The Darwin major version is always 4 greater than the Mac OS X minor
 472   // version for Darwin versions beginning with 6, corresponding to Mac OS X
 473   // 10.2. Since this correspondence may change in the future, warn when
 474   // encountering a version higher than anything seen before. Older Darwin
 475   // versions, or versions that can't be determined, result in
 476   // immediate death.
 477   CHECK(darwin_major_version >= 6);
 478   int mac_os_x_minor_version = darwin_major_version - 4;
 479   DLOG_IF(WARNING, darwin_major_version > 14) << "Assuming Darwin "
 480       << base::IntToString(darwin_major_version) << " is Mac OS X 10."
 481       << base::IntToString(mac_os_x_minor_version);
 482
 483   return mac_os_x_minor_version;
 484 }
 485
 486 // Returns the running system's Mac OS X minor version. This is the |y| value
 487 // in 10.y or 10.y.z.
 488 int MacOSXMinorVersion() {
 489   static int mac_os_x_minor_version = MacOSXMinorVersionInternal();
 490   return mac_os_x_minor_version;
 491 }
 492
 493 enum {
 494   SNOW_LEOPARD_MINOR_VERSION = 6,
 495   LION_MINOR_VERSION = 7,
 496   MOUNTAIN_LION_MINOR_VERSION = 8,
 497   MAVERICKS_MINOR_VERSION = 9,
 498   YOSEMITE_MINOR_VERSION = 10,
 499 };
 500
 501 }  // namespace
 502
 503 #if !defined(BASE_MAC_MAC_UTIL_H_INLINED_GE_10_7)
 504 bool IsOSSnowLeopard() {
 505   return MacOSXMinorVersion() == SNOW_LEOPARD_MINOR_VERSION;
 506 }
 507 #endif
 508
 509 #if !defined(BASE_MAC_MAC_UTIL_H_INLINED_GT_10_7)
 510 bool IsOSLion() {
 511   return MacOSXMinorVersion() == LION_MINOR_VERSION;
 512 }
 513 #endif
 514
 515 #if !defined(BASE_MAC_MAC_UTIL_H_INLINED_GE_10_7)
 516 bool IsOSLionOrLater() {
 517   return MacOSXMinorVersion() >= LION_MINOR_VERSION;
 518 }
 519 #endif
 520
 521 #if !defined(BASE_MAC_MAC_UTIL_H_INLINED_GT_10_8)
 522 bool IsOSMountainLion() {
 523   return MacOSXMinorVersion() == MOUNTAIN_LION_MINOR_VERSION;
 524 }
 525 #endif
 526
 527 #if !defined(BASE_MAC_MAC_UTIL_H_INLINED_GE_10_8)
 528 bool IsOSMountainLionOrLater() {
 529   return MacOSXMinorVersion() >= MOUNTAIN_LION_MINOR_VERSION;
 530 }
 531 #endif
 532
 533 #if !defined(BASE_MAC_MAC_UTIL_H_INLINED_GT_10_9)
 534 bool IsOSMavericks() {
 535   return MacOSXMinorVersion() == MAVERICKS_MINOR_VERSION;
 536 }
 537 #endif
 538
 539 #if !defined(BASE_MAC_MAC_UTIL_H_INLINED_GE_10_9)
 540 bool IsOSMavericksOrLater() {
 541   return MacOSXMinorVersion() >= MAVERICKS_MINOR_VERSION;
 542 }
 543 #endif
 544
 545 #if !defined(BASE_MAC_MAC_UTIL_H_INLINED_GT_10_10)
 546 bool IsOSYosemite() {
 547   return MacOSXMinorVersion() == YOSEMITE_MINOR_VERSION;
 548 }
 549 #endif
 550
 551 #if !defined(BASE_MAC_MAC_UTIL_H_INLINED_GE_10_10)
 552 bool IsOSYosemiteOrLater() {
 553   return MacOSXMinorVersion() >= YOSEMITE_MINOR_VERSION;
 554 }
 555 #endif
 556
 557 #if !defined(BASE_MAC_MAC_UTIL_H_INLINED_GT_10_10)
 558 bool IsOSLaterThanYosemite_DontCallThis() {
 559   return MacOSXMinorVersion() > YOSEMITE_MINOR_VERSION;
 560 }
 561 #endif
 562
 563 std::string GetModelIdentifier() {
 564   std::string return_string;
 565   ScopedIOObject<io_service_t> platform_expert(
 566       IOServiceGetMatchingService(kIOMasterPortDefault,
 567                                   IOServiceMatching("IOPlatformExpertDevice")));
 568   if (platform_expert) {
 569     ScopedCFTypeRef<CFDataRef> model_data(
 570         static_cast<CFDataRef>(IORegistryEntryCreateCFProperty(
 571             platform_expert,
 572             CFSTR("model"),
 573             kCFAllocatorDefault,
 574             0)));
 575     if (model_data) {
 576       return_string =
 577           reinterpret_cast<const char*>(CFDataGetBytePtr(model_data));
 578     }
 579   }
 580   return return_string;
 581 }
 582
 583 bool ParseModelIdentifier(const std::string& ident,
 584                           std::string* type,
 585                           int32* major,
 586                           int32* minor) {
 587   size_t number_loc = ident.find_first_of("0123456789");
 588   if (number_loc == std::string::npos)
 589     return false;
 590   size_t comma_loc = ident.find(',', number_loc);
 591   if (comma_loc == std::string::npos)
 592     return false;
 593   int32 major_tmp, minor_tmp;
 594   std::string::const_iterator begin = ident.begin();
 595   if (!StringToInt(
 596           StringPiece(begin + number_loc, begin + comma_loc), &major_tmp) ||
 597       !StringToInt(
 598           StringPiece(begin + comma_loc + 1, ident.end()), &minor_tmp))
 599     return false;
 600   *type = ident.substr(0, number_loc);
 601   *major = major_tmp;
 602   *minor = minor_tmp;
 603   return true;
 604 }
 605
 606 }  // namespace mac
 607 }  // namespace base