util/mac: Provide wrappers for <launch.h> functions deprecated in 10.10.

The 10.10 SDK deprecates <launch.h>, but this file is still useful and
is used by util/mac/launchd.* and util/mac/service_management.*. Wrap
the <launch.h> functions in versions that ignore the deprecation
warnings.

BUG=crashpad:10
R=rsesek@chromium.org

Review URL: https://codereview.chromium.org/989733003

DEPS

@@ -28,7 +28,7 @@ deps = {
       '32ca1cd8e010d013a606a752fb49a603a3598071',  # svn r2015
   'crashpad/third_party/mini_chromium/mini_chromium':
       Var('chromium_git') + '/chromium/mini_chromium@' +
-      '8773bfd3a0006ee8795b296b6f772e08b7d518c5',
+      'e7847b381703096126b37539c62a0718671d6100',
 }
 
 hooks = [

util/mac/launchd.h

@@ -20,6 +20,114 @@
 
 namespace crashpad {
 
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdeprecated-declarations"
+
+//! \{
+//! \brief Wraps the `<launch.h>` function of the same name.
+//!
+//! The Mac OS X 10.10 SDK deprecates `<launch.h>`, although the functionality
+//! it provides is still useful. These wrappers allow the deprecated functions
+//! to be called without triggering deprecated-declaration warnings.
+
+inline launch_data_t LaunchDataAlloc(launch_data_type_t type) {
+  return launch_data_alloc(type);
+}
+
+inline launch_data_type_t LaunchDataGetType(const launch_data_t data) {
+  return launch_data_get_type(data);
+}
+
+inline void LaunchDataFree(launch_data_t data) {
+  return launch_data_free(data);
+}
+
+inline bool LaunchDataDictInsert(launch_data_t dict,
+                                 const launch_data_t value,
+                                 const char* key) {
+  return launch_data_dict_insert(dict, value, key);
+}
+
+inline launch_data_t LaunchDataDictLookup(const launch_data_t dict,
+                                          const char* key) {
+  return launch_data_dict_lookup(dict, key);
+}
+
+inline size_t LaunchDataDictGetCount(launch_data_t dict) {
+  return launch_data_dict_get_count(dict);
+}
+
+inline bool LaunchDataArraySetIndex(launch_data_t array,
+                                    const launch_data_t value,
+                                    size_t index) {
+  return launch_data_array_set_index(array, value, index);
+}
+
+inline launch_data_t LaunchDataArrayGetIndex(launch_data_t array,
+                                             size_t index) {
+  return launch_data_array_get_index(array, index);
+}
+
+inline size_t LaunchDataArrayGetCount(launch_data_t array) {
+  return launch_data_array_get_count(array);
+}
+
+inline launch_data_t LaunchDataNewInteger(long long integer) {
+  return launch_data_new_integer(integer);
+}
+
+inline launch_data_t LaunchDataNewBool(bool boolean) {
+  return launch_data_new_bool(boolean);
+}
+
+inline launch_data_t LaunchDataNewReal(double real) {
+  return launch_data_new_real(real);
+}
+
+inline launch_data_t LaunchDataNewString(const char* string) {
+  return launch_data_new_string(string);
+}
+
+inline launch_data_t LaunchDataNewOpaque(const void* opaque, size_t size) {
+  return launch_data_new_opaque(opaque, size);
+}
+
+inline long long LaunchDataGetInteger(const launch_data_t data) {
+  return launch_data_get_integer(data);
+}
+
+inline bool LaunchDataGetBool(const launch_data_t data) {
+  return launch_data_get_bool(data);
+}
+
+inline double LaunchDataGetReal(const launch_data_t data) {
+  return launch_data_get_real(data);
+}
+
+inline const char* LaunchDataGetString(const launch_data_t data) {
+  return launch_data_get_string(data);
+}
+
+inline void* LaunchDataGetOpaque(const launch_data_t data) {
+  return launch_data_get_opaque(data);
+}
+
+inline size_t LaunchDataGetOpaqueSize(const launch_data_t data) {
+  return launch_data_get_opaque_size(data);
+}
+
+inline int LaunchDataGetErrno(const launch_data_t data) {
+  return launch_data_get_errno(data);
+}
+
+inline launch_data_t LaunchMsg(const launch_data_t data) {
+  return launch_msg(data);
+}
+
+//! \}
+
+#pragma clang diagnostic pop
+
 //! \brief Converts a Core Foundation-type property list to a launchd-type
 //!     `launch_data_t`.
 //!

util/mac/launchd.mm

@@ -37,7 +37,7 @@ launch_data_t CFPropertyToLaunchData(CFPropertyListRef property_cf) {
       NSDictionary* dictionary_ns = base::mac::CFToNSCast(
           base::mac::CFCastStrict<CFDictionaryRef>(property_cf));
       base::mac::ScopedLaunchData dictionary_launch(
-          launch_data_alloc(LAUNCH_DATA_DICTIONARY));
+          LaunchDataAlloc(LAUNCH_DATA_DICTIONARY));
 
       for (NSString* key in dictionary_ns) {
         if (![key isKindOfClass:[NSString class]]) {
@@ -51,8 +51,7 @@ launch_data_t CFPropertyToLaunchData(CFPropertyListRef property_cf) {
           return nullptr;
         }
 
-        launch_data_dict_insert(
+        LaunchDataDictInsert(dictionary_launch, value_launch, [key UTF8String]);
-            dictionary_launch, value_launch, [key UTF8String]);
       }
 
       data_launch = dictionary_launch.release();
@@ -61,7 +60,7 @@ launch_data_t CFPropertyToLaunchData(CFPropertyListRef property_cf) {
       NSArray* array_ns = base::mac::CFToNSCast(
           base::mac::CFCastStrict<CFArrayRef>(property_cf));
       base::mac::ScopedLaunchData array_launch(
-          launch_data_alloc(LAUNCH_DATA_ARRAY));
+          LaunchDataAlloc(LAUNCH_DATA_ARRAY));
       size_t index = 0;
 
       for (id element_ns in array_ns) {
@@ -72,7 +71,7 @@ launch_data_t CFPropertyToLaunchData(CFPropertyListRef property_cf) {
           return nullptr;
         }
 
-        launch_data_array_set_index(array_launch, element_launch, index++);
+        LaunchDataArraySetIndex(array_launch, element_launch, index++);
       }
 
       data_launch = array_launch.release();
@@ -92,7 +91,7 @@ launch_data_t CFPropertyToLaunchData(CFPropertyListRef property_cf) {
         case kCFNumberLongLongType:
         case kCFNumberCFIndexType:
         case kCFNumberNSIntegerType: {
-          data_launch = launch_data_new_integer([number_ns longLongValue]);
+          data_launch = LaunchDataNewInteger([number_ns longLongValue]);
           break;
         }
 
@@ -100,7 +99,7 @@ launch_data_t CFPropertyToLaunchData(CFPropertyListRef property_cf) {
         case kCFNumberFloat64Type:
         case kCFNumberFloatType:
         case kCFNumberDoubleType: {
-          data_launch = launch_data_new_real([number_ns doubleValue]);
+          data_launch = LaunchDataNewReal([number_ns doubleValue]);
           break;
         }
 
@@ -110,7 +109,7 @@ launch_data_t CFPropertyToLaunchData(CFPropertyListRef property_cf) {
     } else if (type_id_cf == CFBooleanGetTypeID()) {
       CFBooleanRef boolean_cf =
           base::mac::CFCastStrict<CFBooleanRef>(property_cf);
-      data_launch = launch_data_new_bool(CFBooleanGetValue(boolean_cf));
+      data_launch = LaunchDataNewBool(CFBooleanGetValue(boolean_cf));
 
     } else if (type_id_cf == CFStringGetTypeID()) {
       NSString* string_ns = base::mac::CFToNSCast(
@@ -122,12 +121,12 @@ launch_data_t CFPropertyToLaunchData(CFPropertyListRef property_cf) {
       // launchd-842.92.1/support/launchctl.c), uses UTF-8 instead of filesystem
       // encoding, so do the same here. Note that there’s another occurrence of
       // -UTF8String above, used for dictionary keys.
-      data_launch = launch_data_new_string([string_ns UTF8String]);
+      data_launch = LaunchDataNewString([string_ns UTF8String]);
 
     } else if (type_id_cf == CFDataGetTypeID()) {
       NSData* data_ns = base::mac::CFToNSCast(
           base::mac::CFCastStrict<CFDataRef>(property_cf));
-      data_launch = launch_data_new_opaque([data_ns bytes], [data_ns length]);
+      data_launch = LaunchDataNewOpaque([data_ns bytes], [data_ns length]);
     } else {
       base::ScopedCFTypeRef<CFStringRef> type_name_cf(
           CFCopyTypeIDDescription(type_id_cf));

util/mac/launchd_test.mm

@@ -61,9 +61,8 @@ TEST(Launchd, CFPropertyToLaunchData_Integer) {
       NSNumber* integer_ns = integer_nses[index];
       launch_data.reset(CFPropertyToLaunchData(integer_ns));
       ASSERT_TRUE(launch_data.get());
-      ASSERT_EQ(LAUNCH_DATA_INTEGER, launch_data_get_type(launch_data));
+      ASSERT_EQ(LAUNCH_DATA_INTEGER, LaunchDataGetType(launch_data));
-      EXPECT_EQ(
+      EXPECT_EQ([integer_ns longLongValue], LaunchDataGetInteger(launch_data))
-          [integer_ns longLongValue], launch_data_get_integer(launch_data))
           << "index " << index;
     }
   }
@@ -91,9 +90,9 @@ TEST(Launchd, CFPropertyToLaunchData_FloatingPoint) {
       NSNumber* double_ns = double_nses[index];
       launch_data.reset(CFPropertyToLaunchData(double_ns));
       ASSERT_TRUE(launch_data.get());
-      ASSERT_EQ(LAUNCH_DATA_REAL, launch_data_get_type(launch_data));
+      ASSERT_EQ(LAUNCH_DATA_REAL, LaunchDataGetType(launch_data));
       double expected_double_value = [double_ns doubleValue];
-      double observed_double_value = launch_data_get_real(launch_data);
+      double observed_double_value = LaunchDataGetReal(launch_data);
       bool expected_is_nan = std::isnan(expected_double_value);
       EXPECT_EQ(expected_is_nan, std::isnan(observed_double_value));
       if (!expected_is_nan) {
@@ -117,11 +116,11 @@ TEST(Launchd, CFPropertyToLaunchData_Boolean) {
       NSNumber* bool_ns = bool_nses[index];
       launch_data.reset(CFPropertyToLaunchData(bool_ns));
       ASSERT_TRUE(launch_data.get());
-      ASSERT_EQ(LAUNCH_DATA_BOOL, launch_data_get_type(launch_data));
+      ASSERT_EQ(LAUNCH_DATA_BOOL, LaunchDataGetType(launch_data));
       if ([bool_ns boolValue]) {
-        EXPECT_TRUE(launch_data_get_bool(launch_data));
+        EXPECT_TRUE(LaunchDataGetBool(launch_data));
       } else {
-        EXPECT_FALSE(launch_data_get_bool(launch_data));
+        EXPECT_FALSE(LaunchDataGetBool(launch_data));
       }
     }
   }
@@ -141,8 +140,8 @@ TEST(Launchd, CFPropertyToLaunchData_String) {
       NSString* string_ns = string_nses[index];
       launch_data.reset(CFPropertyToLaunchData(string_ns));
       ASSERT_TRUE(launch_data.get());
-      ASSERT_EQ(LAUNCH_DATA_STRING, launch_data_get_type(launch_data));
+      ASSERT_EQ(LAUNCH_DATA_STRING, LaunchDataGetType(launch_data));
-      EXPECT_STREQ([string_ns UTF8String], launch_data_get_string(launch_data));
+      EXPECT_STREQ([string_ns UTF8String], LaunchDataGetString(launch_data));
     }
   }
 }
@@ -156,10 +155,10 @@ TEST(Launchd, CFPropertyToLaunchData_Data) {
     NSData* data_ns = [NSData dataWithBytes:data_c length:sizeof(data_c)];
     launch_data.reset(CFPropertyToLaunchData(data_ns));
     ASSERT_TRUE(launch_data.get());
-    ASSERT_EQ(LAUNCH_DATA_OPAQUE, launch_data_get_type(launch_data));
+    ASSERT_EQ(LAUNCH_DATA_OPAQUE, LaunchDataGetType(launch_data));
-    EXPECT_EQ(sizeof(data_c), launch_data_get_opaque_size(launch_data));
+    EXPECT_EQ(sizeof(data_c), LaunchDataGetOpaqueSize(launch_data));
-    EXPECT_EQ(
+    EXPECT_EQ(0,
-        0, memcmp(launch_data_get_opaque(launch_data), data_c, sizeof(data_c)));
+              memcmp(LaunchDataGetOpaque(launch_data), data_c, sizeof(data_c)));
   }
 }
 
@@ -173,14 +172,13 @@ TEST(Launchd, CFPropertyToLaunchData_Dictionary) {
 
     launch_data.reset(CFPropertyToLaunchData(dictionary_ns));
     ASSERT_TRUE(launch_data.get());
-    ASSERT_EQ(LAUNCH_DATA_DICTIONARY, launch_data_get_type(launch_data));
+    ASSERT_EQ(LAUNCH_DATA_DICTIONARY, LaunchDataGetType(launch_data));
-    EXPECT_EQ([dictionary_ns count], launch_data_dict_get_count(launch_data));
+    EXPECT_EQ([dictionary_ns count], LaunchDataDictGetCount(launch_data));
 
-    launch_data_t launch_lookup_data =
+    launch_data_t launch_lookup_data = LaunchDataDictLookup(launch_data, "key");
-        launch_data_dict_lookup(launch_data, "key");
     ASSERT_TRUE(launch_lookup_data);
-    ASSERT_EQ(LAUNCH_DATA_STRING, launch_data_get_type(launch_lookup_data));
+    ASSERT_EQ(LAUNCH_DATA_STRING, LaunchDataGetType(launch_lookup_data));
-    EXPECT_STREQ("value", launch_data_get_string(launch_lookup_data));
+    EXPECT_STREQ("value", LaunchDataGetString(launch_lookup_data));
   }
 }
 
@@ -192,19 +190,18 @@ TEST(Launchd, CFPropertyToLaunchData_Array) {
 
     launch_data.reset(CFPropertyToLaunchData(array_ns));
     ASSERT_TRUE(launch_data.get());
-    ASSERT_EQ(LAUNCH_DATA_ARRAY, launch_data_get_type(launch_data));
+    ASSERT_EQ(LAUNCH_DATA_ARRAY, LaunchDataGetType(launch_data));
-    EXPECT_EQ([array_ns count], launch_data_array_get_count(launch_data));
+    EXPECT_EQ([array_ns count], LaunchDataArrayGetCount(launch_data));
 
-    launch_data_t launch_lookup_data =
+    launch_data_t launch_lookup_data = LaunchDataArrayGetIndex(launch_data, 0);
-        launch_data_array_get_index(launch_data, 0);
     ASSERT_TRUE(launch_lookup_data);
-    ASSERT_EQ(LAUNCH_DATA_STRING, launch_data_get_type(launch_lookup_data));
+    ASSERT_EQ(LAUNCH_DATA_STRING, LaunchDataGetType(launch_lookup_data));
-    EXPECT_STREQ("element_1", launch_data_get_string(launch_lookup_data));
+    EXPECT_STREQ("element_1", LaunchDataGetString(launch_lookup_data));
 
-    launch_lookup_data = launch_data_array_get_index(launch_data, 1);
+    launch_lookup_data = LaunchDataArrayGetIndex(launch_data, 1);
     ASSERT_TRUE(launch_lookup_data);
-    ASSERT_EQ(LAUNCH_DATA_STRING, launch_data_get_type(launch_lookup_data));
+    ASSERT_EQ(LAUNCH_DATA_STRING, LaunchDataGetType(launch_lookup_data));
-    EXPECT_STREQ("element_2", launch_data_get_string(launch_lookup_data));
+    EXPECT_STREQ("element_2", LaunchDataGetString(launch_lookup_data));
   }
 }
 
@@ -248,55 +245,55 @@ TEST(Launchd, CFPropertyToLaunchData_RealWorldJobDictionary) {
 
     launch_data.reset(CFPropertyToLaunchData(job_dictionary));
     ASSERT_TRUE(launch_data.get());
-    ASSERT_EQ(LAUNCH_DATA_DICTIONARY, launch_data_get_type(launch_data));
+    ASSERT_EQ(LAUNCH_DATA_DICTIONARY, LaunchDataGetType(launch_data));
-    EXPECT_EQ(4u, launch_data_dict_get_count(launch_data));
+    EXPECT_EQ(4u, LaunchDataDictGetCount(launch_data));
 
     launch_data_t launch_lookup_data =
-        launch_data_dict_lookup(launch_data, LAUNCH_JOBKEY_LABEL);
+        LaunchDataDictLookup(launch_data, LAUNCH_JOBKEY_LABEL);
     ASSERT_TRUE(launch_lookup_data);
-    ASSERT_EQ(LAUNCH_DATA_STRING, launch_data_get_type(launch_lookup_data));
+    ASSERT_EQ(LAUNCH_DATA_STRING, LaunchDataGetType(launch_lookup_data));
     EXPECT_STREQ("com.example.job.rebooter",
-                 launch_data_get_string(launch_lookup_data));
+                 LaunchDataGetString(launch_lookup_data));
 
     launch_lookup_data =
-        launch_data_dict_lookup(launch_data, LAUNCH_JOBKEY_ONDEMAND);
+        LaunchDataDictLookup(launch_data, LAUNCH_JOBKEY_ONDEMAND);
     ASSERT_TRUE(launch_lookup_data);
-    ASSERT_EQ(LAUNCH_DATA_BOOL, launch_data_get_type(launch_lookup_data));
+    ASSERT_EQ(LAUNCH_DATA_BOOL, LaunchDataGetType(launch_lookup_data));
-    EXPECT_TRUE(launch_data_get_bool(launch_lookup_data));
+    EXPECT_TRUE(LaunchDataGetBool(launch_lookup_data));
 
     launch_lookup_data =
-        launch_data_dict_lookup(launch_data, LAUNCH_JOBKEY_PROGRAMARGUMENTS);
+        LaunchDataDictLookup(launch_data, LAUNCH_JOBKEY_PROGRAMARGUMENTS);
     ASSERT_TRUE(launch_lookup_data);
-    ASSERT_EQ(LAUNCH_DATA_ARRAY, launch_data_get_type(launch_lookup_data));
+    ASSERT_EQ(LAUNCH_DATA_ARRAY, LaunchDataGetType(launch_lookup_data));
-    EXPECT_EQ(3u, launch_data_array_get_count(launch_lookup_data));
+    EXPECT_EQ(3u, LaunchDataArrayGetCount(launch_lookup_data));
 
     launch_data_t launch_sublookup_data =
-        launch_data_array_get_index(launch_lookup_data, 0);
+        LaunchDataArrayGetIndex(launch_lookup_data, 0);
     ASSERT_TRUE(launch_sublookup_data);
-    ASSERT_EQ(LAUNCH_DATA_STRING, launch_data_get_type(launch_sublookup_data));
+    ASSERT_EQ(LAUNCH_DATA_STRING, LaunchDataGetType(launch_sublookup_data));
-    EXPECT_STREQ("/bin/bash", launch_data_get_string(launch_sublookup_data));
+    EXPECT_STREQ("/bin/bash", LaunchDataGetString(launch_sublookup_data));
 
-    launch_sublookup_data = launch_data_array_get_index(launch_lookup_data, 1);
+    launch_sublookup_data = LaunchDataArrayGetIndex(launch_lookup_data, 1);
     ASSERT_TRUE(launch_sublookup_data);
-    ASSERT_EQ(LAUNCH_DATA_STRING, launch_data_get_type(launch_sublookup_data));
+    ASSERT_EQ(LAUNCH_DATA_STRING, LaunchDataGetType(launch_sublookup_data));
-    EXPECT_STREQ("-c", launch_data_get_string(launch_sublookup_data));
+    EXPECT_STREQ("-c", LaunchDataGetString(launch_sublookup_data));
 
-    launch_sublookup_data = launch_data_array_get_index(launch_lookup_data, 2);
+    launch_sublookup_data = LaunchDataArrayGetIndex(launch_lookup_data, 2);
     ASSERT_TRUE(launch_sublookup_data);
-    ASSERT_EQ(LAUNCH_DATA_STRING, launch_data_get_type(launch_sublookup_data));
+    ASSERT_EQ(LAUNCH_DATA_STRING, LaunchDataGetType(launch_sublookup_data));
-    EXPECT_STREQ("/sbin/reboot", launch_data_get_string(launch_sublookup_data));
+    EXPECT_STREQ("/sbin/reboot", LaunchDataGetString(launch_sublookup_data));
 
     launch_lookup_data =
-        launch_data_dict_lookup(launch_data, LAUNCH_JOBKEY_MACHSERVICES);
+        LaunchDataDictLookup(launch_data, LAUNCH_JOBKEY_MACHSERVICES);
     ASSERT_TRUE(launch_lookup_data);
-    ASSERT_EQ(LAUNCH_DATA_DICTIONARY, launch_data_get_type(launch_lookup_data));
+    ASSERT_EQ(LAUNCH_DATA_DICTIONARY, LaunchDataGetType(launch_lookup_data));
-    EXPECT_EQ(1u, launch_data_dict_get_count(launch_lookup_data));
+    EXPECT_EQ(1u, LaunchDataDictGetCount(launch_lookup_data));
 
-    launch_sublookup_data = launch_data_dict_lookup(
+    launch_sublookup_data = LaunchDataDictLookup(
         launch_lookup_data, "com.example.service.rebooter");
     ASSERT_TRUE(launch_sublookup_data);
-    ASSERT_EQ(LAUNCH_DATA_BOOL, launch_data_get_type(launch_sublookup_data));
+    ASSERT_EQ(LAUNCH_DATA_BOOL, LaunchDataGetType(launch_sublookup_data));
-    EXPECT_TRUE(launch_data_get_bool(launch_sublookup_data));
+    EXPECT_TRUE(LaunchDataGetBool(launch_sublookup_data));
   }
 }
 

util/mac/service_management.cc

@@ -21,16 +21,17 @@
 #include "util/mac/launchd.h"
 #include "util/misc/clock.h"
 
+namespace crashpad {
+
 namespace {
 
 launch_data_t LaunchDataDictionaryForJob(const std::string& label) {
-  base::mac::ScopedLaunchData request(
+  base::mac::ScopedLaunchData request(LaunchDataAlloc(LAUNCH_DATA_DICTIONARY));
-      launch_data_alloc(LAUNCH_DATA_DICTIONARY));
+  LaunchDataDictInsert(
-  launch_data_dict_insert(
+      request, LaunchDataNewString(label.c_str()), LAUNCH_KEY_GETJOB);
-      request, launch_data_new_string(label.c_str()), LAUNCH_KEY_GETJOB);
 
   base::mac::ScopedLaunchData response(launch_msg(request));
-  if (launch_data_get_type(response) != LAUNCH_DATA_DICTIONARY) {
+  if (LaunchDataGetType(response) != LAUNCH_DATA_DICTIONARY) {
     return nullptr;
   }
 
@@ -39,37 +40,34 @@ launch_data_t LaunchDataDictionaryForJob(const std::string& label) {
 
 }  // namespace
 
-namespace crashpad {
-
 bool ServiceManagementSubmitJob(CFDictionaryRef job_cf) {
   base::mac::ScopedLaunchData job_launch(CFPropertyToLaunchData(job_cf));
   if (!job_launch.get()) {
     return false;
   }
 
-  base::mac::ScopedLaunchData jobs(launch_data_alloc(LAUNCH_DATA_ARRAY));
+  base::mac::ScopedLaunchData jobs(LaunchDataAlloc(LAUNCH_DATA_ARRAY));
-  launch_data_array_set_index(jobs, job_launch.release(), 0);
+  LaunchDataArraySetIndex(jobs, job_launch.release(), 0);
 
-  base::mac::ScopedLaunchData request(
+  base::mac::ScopedLaunchData request(LaunchDataAlloc(LAUNCH_DATA_DICTIONARY));
-      launch_data_alloc(LAUNCH_DATA_DICTIONARY));
+  LaunchDataDictInsert(request, jobs.release(), LAUNCH_KEY_SUBMITJOB);
-  launch_data_dict_insert(request, jobs.release(), LAUNCH_KEY_SUBMITJOB);
 
   base::mac::ScopedLaunchData response(launch_msg(request));
 
-  if (launch_data_get_type(response) != LAUNCH_DATA_ARRAY) {
+  if (LaunchDataGetType(response) != LAUNCH_DATA_ARRAY) {
     return false;
   }
 
-  if (launch_data_array_get_count(response) != 1) {
+  if (LaunchDataArrayGetCount(response) != 1) {
     return false;
   }
 
-  launch_data_t response_element = launch_data_array_get_index(response, 0);
+  launch_data_t response_element = LaunchDataArrayGetIndex(response, 0);
-  if (launch_data_get_type(response_element) != LAUNCH_DATA_ERRNO) {
+  if (LaunchDataGetType(response_element) != LAUNCH_DATA_ERRNO) {
     return false;
   }
 
-  int err = launch_data_get_errno(response_element);
+  int err = LaunchDataGetErrno(response_element);
   if (err != 0) {
     return false;
   }
@@ -78,17 +76,16 @@ bool ServiceManagementSubmitJob(CFDictionaryRef job_cf) {
 }
 
 bool ServiceManagementRemoveJob(const std::string& label, bool wait) {
-  base::mac::ScopedLaunchData request(
+  base::mac::ScopedLaunchData request(LaunchDataAlloc(LAUNCH_DATA_DICTIONARY));
-      launch_data_alloc(LAUNCH_DATA_DICTIONARY));
+  LaunchDataDictInsert(
-  launch_data_dict_insert(
+      request, LaunchDataNewString(label.c_str()), LAUNCH_KEY_REMOVEJOB);
-      request, launch_data_new_string(label.c_str()), LAUNCH_KEY_REMOVEJOB);
 
   base::mac::ScopedLaunchData response(launch_msg(request));
-  if (launch_data_get_type(response) != LAUNCH_DATA_ERRNO) {
+  if (LaunchDataGetType(response) != LAUNCH_DATA_ERRNO) {
     return false;
   }
 
-  int err = launch_data_get_errno(response);
+  int err = LaunchDataGetErrno(response);
   if (err == EINPROGRESS) {
     if (wait) {
       // TODO(mark): Use a kqueue to wait for the process to exit. To avoid a
@@ -125,12 +122,12 @@ pid_t ServiceManagementIsJobRunning(const std::string& label) {
     return 0;
   }
 
-  launch_data_t pid = launch_data_dict_lookup(dictionary, LAUNCH_JOBKEY_PID);
+  launch_data_t pid = LaunchDataDictLookup(dictionary, LAUNCH_JOBKEY_PID);
   if (!pid) {
     return 0;
   }
 
-  if (launch_data_get_type(pid) != LAUNCH_DATA_INTEGER) {
+  if (LaunchDataGetType(pid) != LAUNCH_DATA_INTEGER) {
     return 0;
   }