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