Getting service process on Mac to handle having things moved/changed underneath it.

chrome/common/service_process_util_mac.mm

-// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+// Copyright (c) 2011 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/common/service_process_util_posix.h"
 
 #import <Foundation/Foundation.h>
 #include <launch.h>
 
+#include <vector>
+
 #include "base/command_line.h"
 #include "base/file_path.h"
+#include "base/file_util.h"
 #include "base/mac/foundation_util.h"
 #include "base/mac/mac_util.h"
 #include "base/mac/scoped_nsautorelease_pool.h"
 #include "base/path_service.h"
+#include "base/process_util.h"
 #include "base/scoped_nsobject.h"
+#include "base/stringprintf.h"
 #include "base/string_util.h"
 #include "base/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/chrome_version_info.h"
+#include "chrome/common/launchd_mac.h"
 #include "content/common/child_process_host.h"
-#include "third_party/GTM/Foundation/GTMServiceManagement.h"
 
 namespace {
 
-NSString* GetServiceProcessLaunchDFileName() {
-  NSString *bundle_id = [base::mac::MainAppBundle() bundleIdentifier];
-  NSString *label = [bundle_id stringByAppendingPathExtension:@"plist"];
-  return label;
+#define kServiceProcessSessionType "Background"
+
+CFStringRef CopyServiceProcessLaunchDName() {
+  base::mac::ScopedNSAutoreleasePool pool;
+  NSBundle* bundle = base::mac::MainAppBundle();
+  return CFStringCreateCopy(kCFAllocatorDefault,
+                            base::mac::NSToCFCast([bundle bundleIdentifier]));
 }
 
 NSString* GetServiceProcessLaunchDLabel() {
-  NSString *bundle_id = [base::mac::MainAppBundle() bundleIdentifier];
-  NSString *label = [bundle_id stringByAppendingString:@".service_process"];
+  base::mac::ScopedNSAutoreleasePool pool;
+
+  scoped_nsobject<NSString> name(
+      base::mac::CFToNSCast(CopyServiceProcessLaunchDName()));
+  NSString *label = [name stringByAppendingString:@".service_process"];
   FilePath user_data_dir;
   PathService::Get(chrome::DIR_USER_DATA, &user_data_dir);
   std::string user_data_dir_path = user_data_dir.value();
   NSString *ns_path = base::SysUTF8ToNSString(user_data_dir_path);
   ns_path = [ns_path stringByReplacingOccurrencesOfString:@" "
                                                withString:@"_"];
   label = [label stringByAppendingString:ns_path];
   return label;
 }
 
 NSString* GetServiceProcessLaunchDSocketKey() {
   return @"ServiceProcessSocket";
 }
 
 NSString* GetServiceProcessLaunchDSocketEnvVar() {
   NSString *label = GetServiceProcessLaunchDLabel();
   NSString *env_var = [label stringByReplacingOccurrencesOfString:@"."
                                                        withString:@"_"];
   env_var = [env_var stringByAppendingString:@"_SOCKET"];
   env_var = [env_var uppercaseString];
   return env_var;
 }
 
-// Creates the path that it returns. Must be called on the FILE thread.
-NSURL* GetUserAgentPath() {
-  NSArray* library_paths = NSSearchPathForDirectoriesInDomains(
-      NSLibraryDirectory, NSUserDomainMask, true);
-  DCHECK_EQ([library_paths count], 1U);
-  NSString* library_path = [library_paths objectAtIndex:0];
-  NSString* launch_agents_path =
-      [library_path stringByAppendingPathComponent:@"LaunchAgents"];
 
-  NSError* err;
-  if (![[NSFileManager defaultManager] createDirectoryAtPath:launch_agents_path
-                                 withIntermediateDirectories:YES
-                                                  attributes:nil
-                                                       error:&err]) {
-    LOG(ERROR) << "GetUserAgentPath: " << err;
-  }
+class ExecFilePathWatcherDelegate : public FilePathWatcher::Delegate {
+ public:
+  ExecFilePathWatcherDelegate() : process_state_(NULL) { }
+  bool Init(const FilePath& path, ServiceProcessState *process_state);
+  virtual ~ExecFilePathWatcherDelegate() { }
+  virtual void OnFilePathChanged(const FilePath& path) OVERRIDE;
 
-  NSString* plist_file_path =
-      [launch_agents_path
-           stringByAppendingPathComponent:GetServiceProcessLaunchDFileName()];
-  return [NSURL fileURLWithPath:plist_file_path isDirectory:NO];
-}
+private:
+  FSRef executable_fsref_;
+  ServiceProcessState* process_state_;
+};
 
-}
+}  // namespace
 
 // Gets the name of the service process IPC channel.
 IPC::ChannelHandle GetServiceProcessChannel() {
   std::string socket_path;
   scoped_nsobject<NSDictionary> dictionary(
-      base::mac::CFToNSCast(GTMCopyLaunchdExports()));
+      base::mac::CFToNSCast(Launchd::GetInstance()->CopyLaunchdExports()));
   NSString *ns_socket_path =
       [dictionary objectForKey:GetServiceProcessLaunchDSocketEnvVar()];
   if (ns_socket_path) {
     socket_path = base::SysNSStringToUTF8(ns_socket_path);
   }
   return IPC::ChannelHandle(socket_path);
 }
 
 bool ForceServiceProcessShutdown(const std::string& /* version */,
                                  base::ProcessId /* process_id */) {
-  NSString* label = GetServiceProcessLaunchDLabel();
+  CFStringRef label = base::mac::NSToCFCast(GetServiceProcessLaunchDLabel());
   CFErrorRef err = NULL;
-  bool ret = GTMSMJobRemove(reinterpret_cast<CFStringRef>(label), &err);
+  bool ret = Launchd::GetInstance()->RemoveLaunchdJob(label, &err);
   if (!ret) {
     LOG(ERROR) << "ForceServiceProcessShutdown: " << err;
     CFRelease(err);
   }
   return ret;
 }
 
 bool GetServiceProcessData(std::string* version, base::ProcessId* pid) {
-  CFStringRef label =
-      reinterpret_cast<CFStringRef>(GetServiceProcessLaunchDLabel());
-  scoped_nsobject<NSDictionary> launchd_conf(
-      base::mac::CFToNSCast(GTMSMJobCopyDictionary(label)));
+  CFStringRef label = base::mac::NSToCFCast(GetServiceProcessLaunchDLabel());
+  scoped_nsobject<NSDictionary> launchd_conf(base::mac::CFToNSCast(
+      Launchd::GetInstance()->CopyLaunchdJobDictionary(label)));
   if (!launchd_conf.get()) {
     return false;
   }
   // Anything past here will return true in that there does appear
   // to be a service process of some sort registered with launchd.
   if (version) {
     *version = "0";
     NSString *exe_path = [launchd_conf objectForKey:@ LAUNCH_JOBKEY_PROGRAM];
     if (exe_path) {
       NSString *bundle_path = [[[exe_path stringByDeletingLastPathComponent]
@@ skipping 27 matching lines @@
     }
   }
   return true;
 }
 
 bool ServiceProcessState::Initialize() {
   if (!CreateState()) {
     return false;
   }
   CFErrorRef err = NULL;
-  state_->launchd_conf_.reset(GTMSMJobCheckIn(&err));
-  if (!state_->launchd_conf_.get()) {
-    LOG(ERROR) << "InitializePlatformState: " << err;
+  CFDictionaryRef dict =
+      Launchd::GetInstance()->CopyLaunchdDictionaryByCheckingIn(&err);
+
+  if (!dict) {
+    LOG(ERROR) << "CopyLaunchdDictionaryByCheckingIn: " << err;
     CFRelease(err);
     return false;
   }
+  state_->launchd_conf_.reset(dict);
+  state_->ui_message_loop_= base::MessageLoopProxy::CreateForCurrentThread();
   return true;
 }
 
 IPC::ChannelHandle ServiceProcessState::GetServiceProcessChannel() {
   CHECK(state_);
   NSDictionary *ns_launchd_conf = base::mac::CFToNSCast(state_->launchd_conf_);
   NSDictionary* socket_dict =
       [ns_launchd_conf objectForKey:@ LAUNCH_JOBKEY_SOCKETS];
   NSArray* sockets =
       [socket_dict objectForKey:GetServiceProcessLaunchDSocketKey()];
@@ skipping 80 matching lines @@
     // relaunch the service automatically in any other case than exiting
     // cleanly with a 0 return code.
     NSDictionary *keep_alive =
       [NSDictionary
         dictionaryWithObject:[NSNumber numberWithBool:NO]
                       forKey:@ LAUNCH_JOBKEY_KEEPALIVE_SUCCESSFULEXIT];
     NSDictionary *auto_launchd_plist =
       [[NSDictionary alloc] initWithObjectsAndKeys:
         [NSNumber numberWithBool:YES], @ LAUNCH_JOBKEY_RUNATLOAD,
         keep_alive, @ LAUNCH_JOBKEY_KEEPALIVE,
-        @"Background", @ LAUNCH_JOBKEY_LIMITLOADTOSESSIONTYPE,
+        @ kServiceProcessSessionType, @ LAUNCH_JOBKEY_LIMITLOADTOSESSIONTYPE,
         nil];
     [launchd_plist addEntriesFromDictionary:auto_launchd_plist];
   }
   return reinterpret_cast<CFDictionaryRef>(launchd_plist);
 }
 
 // Writes the launchd property list into the user's LaunchAgents directory,
 // creating that directory if needed. This will cause the service process to be
 // auto launched on the next user login.
 bool ServiceProcessState::AddToAutoRun() {
   // We're creating directories and writing a file.
   base::ThreadRestrictions::AssertIOAllowed();
   DCHECK(autorun_command_line_.get());
-
-  base::mac::ScopedNSAutoreleasePool pool;
-  scoped_nsobject<NSDictionary> plist(
-      base::mac::CFToNSCast(CreateServiceProcessLaunchdPlist(
-                                autorun_command_line_.get(), true)));
-  NSURL* plist_url = GetUserAgentPath();
-  return [plist writeToURL:plist_url atomically:YES];
+  base::mac::ScopedCFTypeRef<CFStringRef> name(CopyServiceProcessLaunchDName());
+  base::mac::ScopedCFTypeRef<CFDictionaryRef> plist(
+      CreateServiceProcessLaunchdPlist(autorun_command_line_.get(), true));
+  return Launchd::GetInstance()->WriteLaunchdPlist(Launchd::User,
+                                                   Launchd::Agent,
+                                                   name,
+                                                   plist);
 }
 
 bool ServiceProcessState::RemoveFromAutoRun() {
   // We're killing a file.
   base::ThreadRestrictions::AssertIOAllowed();
+  base::mac::ScopedCFTypeRef<CFStringRef> name(CopyServiceProcessLaunchDName());
+  return Launchd::GetInstance()->DeleteLaunchDPlist(Launchd::User,
+                                                    Launchd::Agent,
+                                                    name);
+}
 
-  base::mac::ScopedNSAutoreleasePool pool;
-  NSURL* plist_url = GetUserAgentPath();
-  SInt32 error = 0;
-  if (!CFURLDestroyResource(reinterpret_cast<CFURLRef>(plist_url), &error)) {
-    LOG(ERROR) << "RemoveFromAutoRun: " << error;
+void ServiceProcessState::StateData::WatchExecutable(Task* shutdown_task) {
+  CFStringRef exe_path = reinterpret_cast<CFStringRef>(CFDictionaryGetValue(
+      launchd_conf_, CFSTR(LAUNCH_JOBKEY_PROGRAM)));
+  if (!exe_path) {
+    LOG(ERROR) << "No " LAUNCH_JOBKEY_PROGRAM;
+    return;
+  }
+
+  // TODO(dmaclach): Move this into a utility function.
+  // Can also be used in launchd_mac.mm.
+  // http://crbug.com/76928
+  CFIndex max = CFStringGetMaximumSizeOfFileSystemRepresentation(exe_path);

[Mark Mentovai, 2011/03/21 16:50:49]

This is an .mm file, just use NSString as discussed before.

[dmac, 2011/03/21 22:59:19]

Done.

+  std::vector<char> c_exe_path(max);
+  CHECK(CFStringGetFileSystemRepresentation(exe_path, &c_exe_path[0], max));
+
+  FilePath executable_path = FilePath(&c_exe_path[0]);
+  scoped_ptr<ExecFilePathWatcherDelegate> delegate(
+      new ExecFilePathWatcherDelegate);
+  if (!delegate->Init(executable_path, state_)) {
+    LOG(ERROR) << "executable_watcher_.Init " << executable_path.value();
+    shutdown_task->Run();

[Mark Mentovai, 2011/03/21 16:50:49]

Are the error cases here really the right place to run (and delete) the
shutdown_task?

[dmac, 2011/03/21 22:59:19]

I completely removed the error case for now. I will log a bug to cleanup, but
the wiring is too complicated to put it in now.

http://code.google.com/p/chromium/issues/detail?id=76987

+    delete shutdown_task;
+  }
+  if (!executable_watcher_.Watch(executable_path,
+                                 delegate.release(),
+                                 ui_message_loop_)) {
+    LOG(ERROR) << "executable_watcher_.watch " << executable_path.value();
+    shutdown_task->Run();
+    delete shutdown_task;
+  }
+}
+
+bool ExecFilePathWatcherDelegate::Init(const FilePath& path,
+                                       ServiceProcessState *process_state) {
+  if (!process_state ||
+      !base::mac::FSRefFromPath(path.value(), &executable_fsref_)) {
     return false;
   }
+  process_state_ = process_state;
   return true;
 }
+
+void ExecFilePathWatcherDelegate::OnFilePathChanged(const FilePath& path) {
+  base::mac::ScopedNSAutoreleasePool pool;
+  bool needs_shutdown = false;
+  bool needs_restart = false;
+
+  bool good_bundle = false;
+  FSRef macos_fsref;
+  if (FSGetCatalogInfo(&executable_fsref_,
+                       0,

[Mark Mentovai, 2011/03/21 16:50:49]

Just put all of these on one line. No sense in making them so vertical when
you’re not even going to use the vertical space to say what the null arguments
are supposed to do.

[dmac, 2011/03/21 22:59:19]

Functionized

+                       NULL,
+                       NULL,
+                       NULL,
+                       &macos_fsref) == noErr) {
+    FSRef contents_fsref;
+    if (FSGetCatalogInfo(&macos_fsref,
+                         0,
+                         NULL,
+                         NULL,
+                         NULL,
+                         &contents_fsref) == noErr) {
+      FSRef bundle_fsref;
+      if (FSGetCatalogInfo(&contents_fsref,
+                           0,
+                           NULL,
+                           NULL,
+                           NULL,
+                           &bundle_fsref) == noErr) {
+        base::mac::ScopedCFTypeRef<CFURLRef> bundle_url(
+            CFURLCreateFromFSRef(kCFAllocatorDefault, &bundle_fsref));
+        if (bundle_url.get()) {
+          base::mac::ScopedCFTypeRef<CFBundleRef> bundle(
+              CFBundleCreate(kCFAllocatorDefault, bundle_url));
+          // Check to see if the bundle still has a minimal structure.
+          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) {
+      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) {
+          was_moved = false;
+        }
+      }
+      if (was_moved) {
+        needs_restart = true;
+      }
+    }
+  }
+  if (needs_shutdown || needs_restart) {

[Mark Mentovai, 2011/03/21 16:50:49]

This is a long function.

Even if you can’t or don’t want to break it up into smaller functions, you
should at least put some blank lines (and maybe comments if needed—you might not
in this function) between portions that do different groups of major work.

[dmac, 2011/03/21 22:59:19]

It's been broken down a bit, and I feel it's pretty readable at this point.

+    // First deal with the plist.
+    base::mac::ScopedCFTypeRef<CFStringRef> name(
+        CopyServiceProcessLaunchDName());
+    if (needs_restart) {
+      base::mac::ScopedCFTypeRef<CFMutableDictionaryRef> plist(
+         Launchd::GetInstance()->ReadLaunchdPlist(Launchd::User,
+                                                  Launchd::Agent,
+                                                  name));
+      if (plist.get()) {
+        base::mac::ScopedNSAutoreleasePool pool;
+        NSMutableDictionary* ns_plist = base::mac::CFToNSCast(plist);
+        std::string new_path = base::mac::PathFromFSRef(executable_fsref_);
+        NSString* ns_new_path = base::SysUTF8ToNSString(new_path);
+        [ns_plist setObject:ns_new_path forKey:@ LAUNCH_JOBKEY_PROGRAM];
+        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()->WriteLaunchdPlist(Launchd::User,
+                                                       Launchd::Agent,
+                                                       name,
+                                                       plist)) {
+          LOG(ERROR) << "Unable to rewrite plist.";
+          needs_shutdown = true;
+        }
+      } else {
+        LOG(ERROR) << "Unable to read plist.";
+        needs_shutdown = true;
+      }
+    }
+    if (needs_shutdown) {
+      if (!process_state_->RemoveFromAutoRun()) {
+        LOG(ERROR) << "Unable to RemoveFromAutoRun.";
+      }
+    }
+
+    // Then deal with the process.
+    CFStringRef session_type = CFSTR(kServiceProcessSessionType);
+    if (needs_restart) {
+      if (!Launchd::GetInstance()->RestartLaunchdJob(Launchd::User,
+                                                     Launchd::Agent,
+                                                     name,
+                                                     session_type)) {
+        LOG(ERROR) << "RestartLaunchdJob";
+        needs_shutdown = true;
+      }
+    }
+    if (needs_shutdown) {
+      if (!Launchd::GetInstance()->ShutdownLaunchdJob(Launchd::User,
+                                                      Launchd::Agent,
+                                                      name,
+                                                      session_type)) {
+        LOG(ERROR) << "ShutdownLaunchdJob";
+      }
+    }
+  }
+}
+

[Mark Mentovai, 2011/03/21 16:50:49]

Blank line at EOF.

[dmac, 2011/03/21 22:59:19]

Done.