mac: Stop using deprecated FSRef functions in service_process_util_mac.mm

chrome/common/service_process_util_mac.mm

 // Copyright (c) 2012 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.
 
 #import <Foundation/Foundation.h>
 #include <launch.h>
 
 #include <memory>
 #include <vector>
 
@@ skipping 12 matching lines @@
 #include "base/strings/sys_string_conversions.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/version.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/mac/launchd.h"
 #include "chrome/common/service_process_util_posix.h"
 #include "components/version_info/version_info.h"
 #include "ipc/unix_domain_socket_util.h"
 
+@interface NSFileManager (YosemiteSDK)
+- (BOOL)getRelationship:(NSURLRelationship*)outRelationship
+            ofDirectory:(NSSearchPathDirectory)directory
+               inDomain:(NSSearchPathDomainMask)domainMask
+            toItemAtURL:(NSURL*)url
+                  error:(NSError**)error;
+@end
+
 using ::base::FilePathWatcher;
 
 namespace {
 
 #define kServiceProcessSessionType "Aqua"
 
 CFStringRef CopyServiceProcessLaunchDName() {
   base::mac::ScopedNSAutoreleasePool pool;
   NSBundle* bundle = base::mac::FrameworkBundle();
   return CFStringCreateCopy(kCFAllocatorDefault,
@@ skipping 11 matching lines @@
   ns_path = [ns_path stringByReplacingOccurrencesOfString:@" "
                                                withString:@"_"];
   label = [label stringByAppendingString:ns_path];
   return label;
 }
 
 NSString* GetServiceProcessLaunchDSocketKey() {
   return @"ServiceProcessSocket";
 }
 
-bool GetParentFSRef(const FSRef& child, FSRef* parent) {
-  return FSGetCatalogInfo(&child, 0, NULL, NULL, NULL, parent) == noErr;
-}
-
 bool RemoveFromLaunchd() {
   // We're killing a file.
   base::ThreadRestrictions::AssertIOAllowed();
   base::ScopedCFTypeRef<CFStringRef> name(CopyServiceProcessLaunchDName());
   return Launchd::GetInstance()->DeletePlist(Launchd::User,
                                              Launchd::Agent,
                                              name);
 }
 
 class ExecFilePathWatcherCallback {
  public:
   ExecFilePathWatcherCallback() {}
   ~ExecFilePathWatcherCallback() {}
 
   bool Init(const base::FilePath& path);
   void NotifyPathChanged(const base::FilePath& path, bool error);
 
  private:
-  FSRef executable_fsref_;
+  base::scoped_nsobject<NSURL> executable_fsref_;
 };
 
 base::FilePath GetServiceProcessSocketName() {
   base::FilePath socket_name;
   PathService::Get(base::DIR_TEMP, &socket_name);
   std::string pipe_name = GetServiceProcessScopedName("srv");
   socket_name = socket_name.Append(pipe_name);
   CHECK_LT(socket_name.value().size(), IPC::kMaxSocketNameLength);
   return socket_name;
 }
@@ skipping 220 matching lines @@
           false,
           base::Bind(&ExecFilePathWatcherCallback::NotifyPathChanged,
                      base::Owned(callback.release())))) {
     DLOG(ERROR) << "executable_watcher.watch " << executable_path.value();
     return false;
   }
   return true;
 }
 
 bool ExecFilePathWatcherCallback::Init(const base::FilePath& path) {
-  return base::mac::FSRefFromPath(path.value(), &executable_fsref_);
+  NSString* path_string = base::mac::FilePathToNSString(path);
+  NSURL* path_url = [NSURL fileURLWithPath:path_string isDirectory:NO];
+  executable_fsref_.reset([[path_url fileReferenceURL] retain]);
+  return executable_fsref_.get() != nil;
 }
 
 void ExecFilePathWatcherCallback::NotifyPathChanged(const base::FilePath& path,
                                                     bool error) {
   if (error) {
     NOTREACHED();  // TODO(darin): Do something smarter?
     return;
   }
 
   base::mac::ScopedNSAutoreleasePool pool;
   bool needs_shutdown = false;
   bool needs_restart = false;
   bool good_bundle = false;
 
-  FSRef macos_fsref;
-  if (GetParentFSRef(executable_fsref_, &macos_fsref)) {
-    FSRef contents_fsref;
-    if (GetParentFSRef(macos_fsref, &contents_fsref)) {
-      FSRef bundle_fsref;
-      if (GetParentFSRef(contents_fsref, &bundle_fsref)) {
-        base::ScopedCFTypeRef<CFURLRef> bundle_url(
-            CFURLCreateFromFSRef(kCFAllocatorDefault, &bundle_fsref));
-        if (bundle_url.get()) {
-          base::ScopedCFTypeRef<CFBundleRef> bundle(
-              CFBundleCreate(kCFAllocatorDefault, bundle_url));
-          // Check to see if the bundle still has a minimal structure.
-          good_bundle = CFBundleGetIdentifier(bundle) != NULL;
-        }
-      }
-    }
+  // Go from bundle/Contents/MacOS/executable to bundle.
+  NSURL* bundle_url = [[[executable_fsref_ URLByDeletingLastPathComponent]
+      URLByDeletingLastPathComponent] URLByDeletingLastPathComponent];
+  if (bundle_url) {
+    base::ScopedCFTypeRef<CFBundleRef> bundle(
+        CFBundleCreate(kCFAllocatorDefault, base::mac::NSToCFCast(bundle_url)));
+    good_bundle = CFBundleGetIdentifier(bundle) != NULL;
   }
+
   if (!good_bundle) {
     needs_shutdown = true;
   } else {
-    Boolean in_trash;
-    OSErr err = FSDetermineIfRefIsEnclosedByFolder(kOnAppropriateDisk,
-                                                   kTrashFolderType,
-                                                   &executable_fsref_,
-                                                   &in_trash);
-    if (err == noErr && in_trash) {
+    bool in_trash = false;
+    NSFileManager* file_manager = [NSFileManager defaultManager];
+    // Apple deprecated FSDetermineIfRefIsEnclosedByFolder() when deploying to
+    // 10.8, but didn't add getRelationship:... until 10.10.  So fall back to
+    // the deprecated function while running on 10.9 (and delete the else block
+    // when Chromium requires OS X 10.10+).
+    if ([file_manager respondsToSelector:@selector(getRelationship:
+                                                       ofDirectory:
+                                                          inDomain:
+                                                       toItemAtURL:
+                                                             error:)]) {
+      NSURLRelationship relationship;
+      if ([file_manager getRelationship:&relationship
+                            ofDirectory:NSTrashDirectory
+                               inDomain:0
+                            toItemAtURL:executable_fsref_
+                                  error:nil]) {
+        in_trash = relationship == NSURLRelationshipContains;
+      }
+    } else {
+      DCHECK(base::mac::IsAtMostOS10_9());
+      Boolean fs_in_trash;
+      FSRef ref;
+      if (CFURLGetFSRef(base::mac::NSToCFCast(executable_fsref_.get()), &ref)) {
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdeprecated-declarations"
+        // This is ok because it only happens on 10.9 and won't be needed once
+        // we stop supporting that.
+        OSErr err = FSDetermineIfRefIsEnclosedByFolder(
+            kOnAppropriateDisk, kTrashFolderType, &ref, &fs_in_trash);
+#pragma clang diagnostic pop
+        if (err == noErr && fs_in_trash)
+          in_trash = true;
+      }
+    }
+    if (in_trash) {
       needs_shutdown = true;
     } else {
       bool was_moved = true;
-      FSRef path_ref;
-      if (base::mac::FSRefFromPath(path.value(), &path_ref)) {
-        if (FSCompareFSRefs(&path_ref, &executable_fsref_) == noErr) {
+      NSString* path_string = base::mac::FilePathToNSString(path);
+      NSURL* path_url = [NSURL fileURLWithPath:path_string isDirectory:NO];
+      NSURL* path_ref = [path_url fileReferenceURL];
+      if (path_ref != nil) {
+        if ([path_ref isEqual:executable_fsref_]) {
           was_moved = false;
         }
       }
       if (was_moved) {
         needs_restart = true;
       }
     }
   }
   if (needs_shutdown || needs_restart) {
     // First deal with the plist.
     base::ScopedCFTypeRef<CFStringRef> name(CopyServiceProcessLaunchDName());
     if (needs_restart) {
       base::ScopedCFTypeRef<CFMutableDictionaryRef> plist(
           Launchd::GetInstance()->CreatePlistFromFile(
               Launchd::User, Launchd::Agent, name));
       if (plist.get()) {
         NSMutableDictionary* ns_plist = base::mac::CFToNSCast(plist);
-        std::string new_path = base::mac::PathFromFSRef(executable_fsref_);
-        NSString* ns_new_path = base::SysUTF8ToNSString(new_path);
+        NSURL* new_path = [executable_fsref_ filePathURL];
+        DCHECK([new_path isFileURL]);
+        NSString* ns_new_path = [new_path path];
         [ns_plist setObject:ns_new_path forKey:@ LAUNCH_JOBKEY_PROGRAM];
         base::scoped_nsobject<NSMutableArray> args([[ns_plist
             objectForKey:@LAUNCH_JOBKEY_PROGRAMARGUMENTS] mutableCopy]);
         [args replaceObjectAtIndex:0 withObject:ns_new_path];
         [ns_plist setObject:args forKey:@ LAUNCH_JOBKEY_PROGRAMARGUMENTS];
         if (!Launchd::GetInstance()->WritePlistToFile(Launchd::User,
                                                       Launchd::Agent,
                                                       name,
                                                       plist)) {
           DLOG(ERROR) << "Unable to rewrite plist.";
@@ skipping 27 matching lines @@
       CFErrorRef err = NULL;
       if (!Launchd::GetInstance()->RemoveJob(label, &err)) {
         base::ScopedCFTypeRef<CFErrorRef> scoped_err(err);
         DLOG(ERROR) << "RemoveJob " << err;
         // Exiting with zero, so launchd doesn't restart the process.
         exit(0);
       }
     }
   }
 }