Make the mac service process handling code clean itself up properly as far as launchd is concerned.

chrome/common/service_process_util_win.cc

Index: chrome/common/service_process_util_win.cc
diff --git a/chrome/common/service_process_util_win.cc b/chrome/common/service_process_util_win.cc
index 2d5db856c4a2f4830aafbc545f1ff76467b67423..b8e2d85bbedf961b4e29afe58d9c6b489ae688bd 100644
--- a/chrome/common/service_process_util_win.cc
+++ b/chrome/common/service_process_util_win.cc
@@ -20,14 +20,16 @@
 
 namespace {
 
+const char* kTerminateEventSuffix = "_service_terminate_evt";
+
 string16 GetServiceProcessReadyEventName() {
   return UTF8ToWide(
       GetServiceProcessScopedVersionedName("_service_ready"));
 }
 
-string16 GetServiceProcessShutdownEventName() {
+string16 GetServiceProcessTerminateEventName() {
   return UTF8ToWide(
-      GetServiceProcessScopedVersionedName("_service_shutdown_evt"));
+      GetServiceProcessScopedVersionedName(kTerminateEventSuffix));
 }
 
 std::string GetServiceProcessAutoRunKey() {
@@ -46,29 +48,29 @@ std::string GetObsoleteServiceProcessAutoRunKey() {
   return scoped_name;
 }
 
-class ServiceProcessShutdownMonitor
+class ServiceProcessTerminateMonitor
     : public base::win::ObjectWatcher::Delegate {
  public:
-  explicit ServiceProcessShutdownMonitor(Task* shutdown_task)
-      : shutdown_task_(shutdown_task) {
+  explicit ServiceProcessTerminateMonitor(Task* terminate_task)
+      : terminate_task_(terminate_task) {
   }
   void Start() {
-    string16 event_name = GetServiceProcessShutdownEventName();
+    string16 event_name = GetServiceProcessTerminateEventName();
     CHECK(event_name.length() <= MAX_PATH);
-    shutdown_event_.Set(CreateEvent(NULL, TRUE, FALSE, event_name.c_str()));
-    watcher_.StartWatching(shutdown_event_.Get(), this);
+    terminate_event_.Set(CreateEvent(NULL, TRUE, FALSE, event_name.c_str()));
+    watcher_.StartWatching(terminate_event_.Get(), this);
   }
 
   // base::ObjectWatcher::Delegate implementation.
   virtual void OnObjectSignaled(HANDLE object) {
-    shutdown_task_->Run();
-    shutdown_task_.reset();
+    terminate_task_->Run();
+    terminate_task_.reset();
   }
 
  private:
-  base::win::ScopedHandle shutdown_event_;
+  base::win::ScopedHandle terminate_event_;
   base::win::ObjectWatcher watcher_;
-  scoped_ptr<Task> shutdown_task_;
+  scoped_ptr<Task> terminate_task_;
 };
 
 }  // namespace
@@ -80,15 +82,15 @@ IPC::ChannelHandle GetServiceProcessChannel() {
 
 bool ForceServiceProcessShutdown(const std::string& version,
                                  base::ProcessId process_id) {
-  base::win::ScopedHandle shutdown_event;
+  base::win::ScopedHandle terminate_event;
   std::string versioned_name = version;
-  versioned_name.append("_service_shutdown_evt");
+  versioned_name.append(kTerminateEventSuffix);
   string16 event_name =
       UTF8ToWide(GetServiceProcessScopedName(versioned_name));
-  shutdown_event.Set(OpenEvent(EVENT_MODIFY_STATE, FALSE, event_name.c_str()));
-  if (!shutdown_event.IsValid())
+  terminate_event.Set(OpenEvent(EVENT_MODIFY_STATE, FALSE, event_name.c_str()));
+  if (!terminate_event.IsValid())
     return false;
-  SetEvent(shutdown_event.Get());
+  SetEvent(terminate_event.Get());
   return true;
 }
 
@@ -105,7 +107,7 @@ bool CheckServiceProcessReady() {
 struct ServiceProcessState::StateData {
   // An event that is signaled when a service process is ready.
   base::win::ScopedHandle ready_event;
-  scoped_ptr<ServiceProcessShutdownMonitor> shutdown_monitor;
+  scoped_ptr<ServiceProcessTerminateMonitor> terminate_monitor;
 };
 
 void ServiceProcessState::CreateState() {
@@ -129,17 +131,17 @@ bool ServiceProcessState::TakeSingletonLock() {
 }
 
 bool ServiceProcessState::SignalReady(
-    base::MessageLoopProxy* message_loop_proxy, Task* shutdown_task) {
+    base::MessageLoopProxy* message_loop_proxy, Task* terminate_task) {
   DCHECK(state_);
   DCHECK(state_->ready_event.IsValid());
-  scoped_ptr<Task> scoped_shutdown_task(shutdown_task);
+  scoped_ptr<Task> scoped_terminate_task(terminate_task);
   if (!SetEvent(state_->ready_event.Get())) {
     return false;
   }
-  if (shutdown_task) {
-    state_->shutdown_monitor.reset(
-        new ServiceProcessShutdownMonitor(scoped_shutdown_task.release()));
-    state_->shutdown_monitor->Start();
+  if (terminate_task) {
+    state_->terminate_monitor.reset(
+        new ServiceProcessTerminateMonitor(scoped_terminate_task.release()));
+    state_->terminate_monitor->Start();
   }
   return true;
 }