mac: Update relauncher to not use deprecated APIs.

chrome/browser/mac/relauncher.mm

 // Copyright 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.
 
 #include "chrome/browser/mac/relauncher.h"
 
-#include <ApplicationServices/ApplicationServices.h>
+#import <AppKit/AppKit.h>
+
 #include <AvailabilityMacros.h>
 #include <crt_externs.h>
 #include <dlfcn.h>
 #include <stddef.h>
 #include <string.h>
 #include <sys/event.h>
 #include <sys/time.h>
 #include <sys/types.h>
 #include <unistd.h>
 
 #include <string>
 #include <vector>
 
 #include "base/files/file_util.h"
 #include "base/files/scoped_file.h"
 #include "base/logging.h"
 #include "base/mac/mac_logging.h"
 #include "base/mac/mac_util.h"
-#include "base/mac/scoped_cftyperef.h"
+#include "base/mac/scoped_nsautorelease_pool.h"
+#include "base/mac/scoped_nsobject.h"
 #include "base/path_service.h"
 #include "base/posix/eintr_wrapper.h"
 #include "base/process/launch.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/sys_string_conversions.h"
 #include "chrome/browser/mac/install_from_dmg.h"
 #include "chrome/common/chrome_switches.h"
 #include "content/public/common/content_paths.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/main_function_params.h"
@@ skipping 201 matching lines @@
                << ", fflags " << event.fflags << ", ident " << event.ident;
     return;
   }
 }
 
 }  // namespace
 
 namespace internal {
 
 int RelauncherMain(const content::MainFunctionParams& main_parameters) {
+  base::mac::ScopedNSAutoreleasePool pool;
+
   // CommandLine rearranges the order of the arguments returned by
   // main_parameters.argv(), rendering it impossible to determine which
   // arguments originally came before kRelauncherArgSeparator and which came
   // after. It's crucial to distinguish between these because only those
   // after the separator should be given to the relaunched process; it's also
   // important to not treat the path to the relaunched process as a "loose"
   // argument. NXArgc and NXArgv are pointers to the original argc and argv as
   // passed to main(), so use those. Access them through _NSGetArgc and
   // _NSGetArgv because NXArgc and NXArgv are normally only available to a
   // main executable via crt1.o and this code will run from a dylib, and
@@ skipping 16 matching lines @@
     LOG(ERROR) << "relauncher process invoked with unexpected arguments";
     return 1;
   }
 
   RelauncherSynchronizeWithParent();
 
   // The capacity for relaunch_args is 4 less than argc, because it
   // won't contain the argv[0] of the relauncher process, the
   // RelauncherTypeArg() at argv[1], kRelauncherArgSeparator, or the
   // executable path of the process to be launched.
-  base::ScopedCFTypeRef<CFMutableArrayRef> relaunch_args(
-      CFArrayCreateMutable(NULL, argc - 4, &kCFTypeArrayCallBacks));
-  if (!relaunch_args) {
-    LOG(ERROR) << "CFArrayCreateMutable";
-    return 1;
-  }
+  base::scoped_nsobject<NSMutableArray> relaunch_args(
+      [[NSMutableArray alloc] initWithCapacity:argc - 4]);
 
   // Figure out what to execute, what arguments to pass it, and whether to
   // start it in the background.
   bool background = false;
   bool in_relaunch_args = false;
   std::string dmg_bsd_device_name;
   bool seen_relaunch_executable = false;
   std::string relaunch_executable;
   const std::string relauncher_arg_separator(kRelauncherArgSeparator);
   const std::string relauncher_dmg_device_arg =
@@ skipping 19 matching lines @@
       }
     } else {
       if (!seen_relaunch_executable) {
         // The first argument after kRelauncherBackgroundArg is the path to
         // the executable file or .app bundle directory. The Launch Services
         // interface wants this separate from the rest of the arguments. In
         // the relaunched process, this path will still be visible at argv[0].
         relaunch_executable.assign(arg);
         seen_relaunch_executable = true;
       } else {
-        base::ScopedCFTypeRef<CFStringRef> arg_cf(
-            base::SysUTF8ToCFStringRef(arg));
-        if (!arg_cf) {
-          LOG(ERROR) << "base::SysUTF8ToCFStringRef failed for " << arg;
+
+        NSString* arg_string = base::SysUTF8ToNSString(arg);
+        if (!arg_string) {
+          LOG(ERROR) << "base::SysUTF8ToNSString failed for " << arg;
           return 1;
         }
-        CFArrayAppendValue(relaunch_args, arg_cf);
+        [relaunch_args addObject:arg_string];
       }
     }
   }
 
   if (!seen_relaunch_executable) {
     LOG(ERROR) << "nothing to relaunch";
     return 1;
   }
 
-  FSRef app_fsref;
-  if (!base::mac::FSRefFromPath(relaunch_executable, &app_fsref)) {
-    LOG(ERROR) << "base::mac::FSRefFromPath failed for " << relaunch_executable;
+  NSString* path = base::SysUTF8ToNSString(relaunch_executable);
+  base::scoped_nsobject<NSURL> url([[NSURL alloc] initFileURLWithPath:path]);
+  NSDictionary* configuration =
+      @{NSWorkspaceLaunchConfigurationArguments : (relaunch_args.get())};
+
+  NSRunningApplication *application = [[NSWorkspace sharedWorkspace]
+      launchApplicationAtURL:url
+                     options:NSWorkspaceLaunchDefault |
+                             NSWorkspaceLaunchWithErrorPresentation |
+                             (background ? NSWorkspaceLaunchWithoutActivation
+                                         : 0) |
+                             NSWorkspaceLaunchNewInstance
+               configuration:configuration
+                       error:nil];
+  if (!application) {
+    LOG(ERROR) << "Failed to relaunch " << relaunch_executable;
     return 1;
   }
 
-  LSApplicationParameters ls_parameters = {
-    0,  // version
-    kLSLaunchDefaults | kLSLaunchAndDisplayErrors | kLSLaunchNewInstance |
-        (background ? kLSLaunchDontSwitch : 0),
-    &app_fsref,
-    NULL,  // asyncLaunchRefCon
-    NULL,  // environment
-    relaunch_args,
-    NULL   // initialEvent
-  };
-
-  OSStatus status = LSOpenApplication(&ls_parameters, NULL);
-  if (status != noErr) {
-    OSSTATUS_LOG(ERROR, status) << "LSOpenApplication";
-    return 1;
-  }
-
   // The application should have relaunched (or is in the process of
   // relaunching). From this point on, only clean-up tasks should occur, and
   // failures are tolerable.
 
   if (!dmg_bsd_device_name.empty()) {
     EjectAndTrashDiskImage(dmg_bsd_device_name);
   }
 
   return 0;
 }
 
 }  // namespace internal
 
 }  // namespace mac_relauncher