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

chrome/common/service_process_util_mac.mm

 // 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/service_process_util_posix.h"
 
 #import <Foundation/Foundation.h>
 #include <launch.h>
 
 #include <vector>
@@ skipping 49 matching lines @@
   return @"ServiceProcessSocket";
 }
 
 bool GetParentFSRef(const FSRef& child, FSRef* parent) {
   return FSGetCatalogInfo(&child, 0, NULL, NULL, NULL, parent) == noErr;
 }
 
 bool RemoveFromLaunchd() {
   // We're killing a file.
   base::ThreadRestrictions::AssertIOAllowed();
-  base::mac::ScopedCFTypeRef<CFStringRef> name(CopyServiceProcessLaunchDName());
-  return Launchd::GetInstance()->DeletePlist(Launchd::User,
-                                             Launchd::Agent,
-                                             name);
+  base::ScopedCFTypeRef<CFStringRef> name(CopyServiceProcessLaunchDName());
+  return Launchd::GetInstance()->DeletePlist(
+      Launchd::User, Launchd::Agent, name);
 }
 
 class ExecFilePathWatcherCallback {
  public:
   ExecFilePathWatcherCallback() {}
   ~ExecFilePathWatcherCallback() {}
 
   bool Init(const base::FilePath& path);
   void NotifyPathChanged(const base::FilePath& path, bool error);
 
@@ skipping 204 matching lines @@
   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::ScopedCFTypeRef<CFStringRef> name(CopyServiceProcessLaunchDName());
-  base::mac::ScopedCFTypeRef<CFDictionaryRef> plist(
+  base::ScopedCFTypeRef<CFStringRef> name(CopyServiceProcessLaunchDName());
+  base::ScopedCFTypeRef<CFDictionaryRef> plist(
       CreateServiceProcessLaunchdPlist(autorun_command_line_.get(), true));
   return Launchd::GetInstance()->WritePlistToFile(Launchd::User,
                                                   Launchd::Agent,
                                                   name,
                                                   plist);
 }
 
 bool ServiceProcessState::RemoveFromAutoRun() {
   return RemoveFromLaunchd();
 }
@@ skipping 41 matching lines @@
   bool needs_shutdown = false;
   bool needs_restart = false;
   bool good_bundle = false;
 
   FSRef macos_fsref;
   if (GetParentFSRef(executable_fsref_, &macos_fsref)) {
     FSRef contents_fsref;
     if (GetParentFSRef(macos_fsref, &contents_fsref)) {
       FSRef bundle_fsref;
       if (GetParentFSRef(contents_fsref, &bundle_fsref)) {
-        base::mac::ScopedCFTypeRef<CFURLRef> bundle_url(
+        base::ScopedCFTypeRef<CFURLRef> bundle_url(
             CFURLCreateFromFSRef(kCFAllocatorDefault, &bundle_fsref));
         if (bundle_url.get()) {
-          base::mac::ScopedCFTypeRef<CFBundleRef> bundle(
+          base::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 {
@@ skipping 12 matching lines @@
           was_moved = false;
         }
       }
       if (was_moved) {
         needs_restart = true;
       }
     }
   }
   if (needs_shutdown || needs_restart) {
     // First deal with the plist.
-    base::mac::ScopedCFTypeRef<CFStringRef> name(
-        CopyServiceProcessLaunchDName());
+    base::ScopedCFTypeRef<CFStringRef> name(CopyServiceProcessLaunchDName());
     if (needs_restart) {
-      base::mac::ScopedCFTypeRef<CFMutableDictionaryRef> plist(
-         Launchd::GetInstance()->CreatePlistFromFile(Launchd::User,
-                                                     Launchd::Agent,
-                                                     name));
+      base::ScopedCFTypeRef<CFMutableDictionaryRef> plist(
+          Launchd::GetInstance()->CreatePlistFromFile(
+              Launchd::User, Launchd::Agent, name));
       if (plist.get()) {
         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];
@@ skipping 24 matching lines @@
                                               session_type)) {
         DLOG(ERROR) << "RestartLaunchdJob";
         needs_shutdown = true;
       }
     }
     if (needs_shutdown) {
       CFStringRef label =
           base::mac::NSToCFCast(GetServiceProcessLaunchDLabel());
       CFErrorRef err = NULL;
       if (!Launchd::GetInstance()->RemoveJob(label, &err)) {
-        base::mac::ScopedCFTypeRef<CFErrorRef> scoped_err(err);
+        base::ScopedCFTypeRef<CFErrorRef> scoped_err(err);
         DLOG(ERROR) << "RemoveJob " << err;
         // Exiting with zero, so launchd doesn't restart the process.
         exit(0);
       }
     }
   }
 }