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

chrome/common/mac/mock_launchd.cc

 // Copyright (c) 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/common/mac/mock_launchd.h"
 
 #include <CoreFoundation/CoreFoundation.h>
 #include <sys/socket.h>
 #include <sys/un.h>
 
@@ skipping 65 matching lines @@
       base::StringPrintf(info_plist_format,
                          name.c_str(),
                          name.c_str(),
                          version_info.Version().c_str());
   len = info_plist_data.length();
   if (file_util::WriteFile(info_plist, info_plist_data.c_str(), len) != len) {
     return false;
   }
   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();
 }
 
 MockLaunchd::MockLaunchd(const base::FilePath& file,
                          base::MessageLoop* loop,
                          bool create_socket,
                          bool as_service)
     : file_(file),
       message_loop_(loop),
@@ skipping 17 matching lines @@
 }
 
 CFDictionaryRef MockLaunchd::CopyExports() {
   if (!create_socket_) {
     ADD_FAILURE();
     return NULL;
   }
 
   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);
   return CFDictionaryCreate(kCFAllocatorDefault,
                             keys,
                             values,
                             arraysize(keys),
                             &kCFTypeDictionaryKeyCallBacks,
                             &kCFTypeDictionaryValueCallBacks);
 }
 
 CFDictionaryRef MockLaunchd::CopyJobDictionary(CFStringRef label) {
   if (!as_service_) {
     scoped_ptr<MultiProcessLock> running_lock(
         TakeNamedLock(pipe_name_, false));
     if (running_lock.get())
       return NULL;
   }
 
   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);
   return CFDictionaryCreate(kCFAllocatorDefault,
                             keys,
                             values,
                             arraysize(keys),
                             &kCFTypeDictionaryKeyCallBacks,
                             &kCFTypeDictionaryValueCallBacks);
 }
 
 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 };
     const void *values[] = { path, args };
     COMPILE_ASSERT(arraysize(keys) == arraysize(values),
                    array_sizes_must_match);
     return CFDictionaryCreate(kCFAllocatorDefault,
                               keys,
                               values,
                               arraysize(keys),
@@ skipping 12 matching lines @@
       base::strlcpy(unix_addr.sun_path, pipe_name_.c_str(), kMaxPipeNameLength);
   DCHECK_EQ(pipe_name_.length(), path_len);
   unix_addr.sun_len = SUN_LEN(&unix_addr);
 
   CFSocketSignature signature;
   signature.protocolFamily = PF_UNIX;
   signature.socketType = SOCK_STREAM;
   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;
 
   CFSocketRef socket =
       CFSocketCreateWithSocketSignature(NULL, &signature, 0, NULL, NULL);
 
   local_pipe = CFSocketGetNative(socket);
   EXPECT_NE(-1, local_pipe);
   if (local_pipe == -1) {
     if (error) {
       *error = CFErrorCreate(kCFAllocatorDefault, kCFErrorDomainPOSIX,
                              errno, NULL);
     }
     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,
                          arraysize(socket_keys),
                          &kCFTypeDictionaryKeyCallBacks,
                          &kCFTypeDictionaryValueCallBacks));
   const void *keys[] = { program, program_args, socket_key };
   const void *values[] = { path, args, socket_dict };
   COMPILE_ASSERT(arraysize(keys) == arraysize(values), array_sizes_must_match);
   return CFDictionaryCreate(kCFAllocatorDefault,
@@ skipping 16 matching lines @@
                              CFStringRef session_type) {
   restart_called_ = true;
   message_loop_->PostTask(FROM_HERE, base::MessageLoop::QuitClosure());
   return true;
 }
 
 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);
 }
 
 bool MockLaunchd::WritePlistToFile(Domain domain,
                                    Type type,
                                    CFStringRef name,
                                    CFDictionaryRef dict) {
   write_called_ = true;
   return true;
 }
 
 bool MockLaunchd::DeletePlist(Domain domain,
                               Type type,
                               CFStringRef name) {
   delete_called_ = true;
   return true;
 }
 
 void MockLaunchd::SignalReady() {
   ASSERT_TRUE(as_service_);
   running_lock_.reset(TakeNamedLock(pipe_name_, true));
 }