mac: Replace base::mac::ScopedCFTypeRef with base::ScopedCFTypeRef.

chrome/common/mac/mock_launchd.cc

Index: chrome/common/mac/mock_launchd.cc
diff --git a/chrome/common/mac/mock_launchd.cc b/chrome/common/mac/mock_launchd.cc
index bc08bf83697bd4b0a4c0962aae141302ce8ab2af..6a3954043cbb4b5711bba56520bf234561789386 100644
--- a/chrome/common/mac/mock_launchd.cc
+++ b/chrome/common/mac/mock_launchd.cc
@@ -83,12 +83,12 @@ bool MockLaunchd::MakeABundle(const base::FilePath& dst,
   }
   const UInt8* bundle_root_path =
       reinterpret_cast<const UInt8*>(bundle_root->value().c_str());
-  base::mac::ScopedCFTypeRef<CFURLRef> url(
+  base::ScopedCFTypeRef<CFURLRef> url(
       CFURLCreateFromFileSystemRepresentation(kCFAllocatorDefault,
                                               bundle_root_path,
                                               bundle_root->value().length(),
                                               true));
-  base::mac::ScopedCFTypeRef<CFBundleRef> bundle(
+  base::ScopedCFTypeRef<CFBundleRef> bundle(
       CFBundleCreate(kCFAllocatorDefault, url));
   return bundle.get();
 }
@@ -126,9 +126,8 @@ CFDictionaryRef MockLaunchd::CopyExports() {
 
   CFStringRef env_var =
       base::mac::NSToCFCast(GetServiceProcessLaunchDSocketEnvVar());
-  base::mac::ScopedCFTypeRef<CFStringRef> socket_path(
-      CFStringCreateWithCString(kCFAllocatorDefault, pipe_name_.c_str(),
-                                kCFStringEncodingUTF8));
+  base::ScopedCFTypeRef<CFStringRef> socket_path(CFStringCreateWithCString(
+      kCFAllocatorDefault, pipe_name_.c_str(), kCFStringEncodingUTF8));

[Mark Mentovai, 2013/06/21 20:29:40]

On something like this, the old argument formatting was nonconformant, but I
still think that it’s more readable to put the line break after socket_path( so
that you can see the CFStringCreateWithCString function call along with at least
its first argument.

Conceptually this statement does the same thing as the previous, except it’s
using a constructor to initialize something instead of an assignment. But I
wouldn’t expect to read
  CFStringRef env_var = base::mac::NSToCFCast(
      GetServiceProcessLaunchDSocketEnvVar());
I’d expect the break after the =.

[Nico, 2013/06/21 21:09:06]

For C++ code, the formatting produced by clang-format has gone through many
rounds of discussions  on c-style, and what it currently does (for
-style=Google) is Google-internal agreed-upon formatting. (-style=Chromium does
a few tweaks on top of that based on
http://www.chromium.org/developers/coding-style). If you disagree with a format
decision, it's best to file a bug at go/clang-format-bug

   const void *keys[] = { env_var };
   const void *values[] = { socket_path };
   COMPILE_ASSERT(arraysize(keys) == arraysize(values), array_sizes_must_match);
@@ -151,10 +150,10 @@ CFDictionaryRef MockLaunchd::CopyJobDictionary(CFStringRef label) {
   CFStringRef program = CFSTR(LAUNCH_JOBKEY_PROGRAM);
   CFStringRef program_pid = CFSTR(LAUNCH_JOBKEY_PID);
   const void *keys[] = { program, program_pid };
-  base::mac::ScopedCFTypeRef<CFStringRef> path(
+  base::ScopedCFTypeRef<CFStringRef> path(
       base::SysUTF8ToCFStringRef(file_.value()));
   int process_id = base::GetCurrentProcId();
-  base::mac::ScopedCFTypeRef<CFNumberRef> pid(
+  base::ScopedCFTypeRef<CFNumberRef> pid(
       CFNumberCreate(NULL, kCFNumberIntType, &process_id));
   const void *values[] = { path, pid };
   COMPILE_ASSERT(arraysize(keys) == arraysize(values), array_sizes_must_match);
@@ -170,14 +169,11 @@ CFDictionaryRef MockLaunchd::CopyDictionaryByCheckingIn(CFErrorRef* error) {
   checkin_called_ = true;
   CFStringRef program = CFSTR(LAUNCH_JOBKEY_PROGRAM);
   CFStringRef program_args = CFSTR(LAUNCH_JOBKEY_PROGRAMARGUMENTS);
-  base::mac::ScopedCFTypeRef<CFStringRef> path(
+  base::ScopedCFTypeRef<CFStringRef> path(
       base::SysUTF8ToCFStringRef(file_.value()));
   const void *array_values[] = { path.get() };
-  base::mac::ScopedCFTypeRef<CFArrayRef> args(
-      CFArrayCreate(kCFAllocatorDefault,
-                    array_values,
-                    1,
-                    &kCFTypeArrayCallBacks));
+  base::ScopedCFTypeRef<CFArrayRef> args(CFArrayCreate(

[Mark Mentovai, 2013/06/21 20:29:40]

Same here.

+      kCFAllocatorDefault, array_values, 1, &kCFTypeArrayCallBacks));
 
   if (!create_socket_) {
     const void *keys[] = { program, program_args };
@@ -210,7 +206,7 @@ CFDictionaryRef MockLaunchd::CopyDictionaryByCheckingIn(CFErrorRef* error) {
   signature.protocol = 0;
   size_t unix_addr_len = offsetof(struct sockaddr_un,
                                   sun_path) + path_len + 1;
-  base::mac::ScopedCFTypeRef<CFDataRef> address(
+  base::ScopedCFTypeRef<CFDataRef> address(
       CFDataCreate(NULL, reinterpret_cast<UInt8*>(&unix_addr), unix_addr_len));
   signature.address = address;
 
@@ -227,20 +223,17 @@ CFDictionaryRef MockLaunchd::CopyDictionaryByCheckingIn(CFErrorRef* error) {
     return NULL;
   }
 
-  base::mac::ScopedCFTypeRef<CFNumberRef> socket_fd(
+  base::ScopedCFTypeRef<CFNumberRef> socket_fd(
       CFNumberCreate(NULL, kCFNumberIntType, &local_pipe));
   const void *socket_array_values[] = { socket_fd };
-  base::mac::ScopedCFTypeRef<CFArrayRef> sockets(
-      CFArrayCreate(kCFAllocatorDefault,
-                    socket_array_values,
-                    1,
-                    &kCFTypeArrayCallBacks));
+  base::ScopedCFTypeRef<CFArrayRef> sockets(CFArrayCreate(
+      kCFAllocatorDefault, socket_array_values, 1, &kCFTypeArrayCallBacks));
   CFStringRef socket_dict_key = CFSTR("ServiceProcessSocket");
   const void *socket_keys[] = { socket_dict_key };
   const void *socket_values[] = { sockets };
   COMPILE_ASSERT(arraysize(socket_keys) == arraysize(socket_values),
                  socket_array_sizes_must_match);
-  base::mac::ScopedCFTypeRef<CFDictionaryRef> socket_dict(
+  base::ScopedCFTypeRef<CFDictionaryRef> socket_dict(
       CFDictionaryCreate(kCFAllocatorDefault,
                          socket_keys,
                          socket_values,
@@ -277,8 +270,7 @@ CFMutableDictionaryRef MockLaunchd::CreatePlistFromFile(
     Domain domain,
     Type type,
     CFStringRef name)  {
-  base::mac::ScopedCFTypeRef<CFDictionaryRef> dict(
-      CopyDictionaryByCheckingIn(NULL));
+  base::ScopedCFTypeRef<CFDictionaryRef> dict(CopyDictionaryByCheckingIn(NULL));
   return CFDictionaryCreateMutableCopy(kCFAllocatorDefault, 0, dict);
 }