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

chrome/browser/mac/keychain_reauthorize.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/browser/mac/keychain_reauthorize.h"
 
 #import <Foundation/Foundation.h>
 #include <Security/Security.h>
 
 #include <algorithm>
@@ skipping 100 matching lines @@
 }  // namespace
 
 void KeychainReauthorize() {
   ScopedSecKeychainSetUserInteractionAllowed user_interaction_allowed(FALSE);
 
   // Apple's documentation (Keychain Services Reference, Constants/Mac OS X
   // Keychain Services API Constants/Keychain Item Class Constants) says to
   // use CSSM_DL_DB_RECORD_ALL_KEYS, but that doesn't work.
   // CSSM_DL_DB_RECORD_ANY (as used by SecurityTool's keychain-dump) does
   // work.
-  base::mac::ScopedCFTypeRef<SecKeychainSearchRef> search(
-    CrSKeychainSearchCreateFromAttributes(NULL,
-                                          CSSM_DL_DB_RECORD_ANY,
-                                          NULL));
+  base::ScopedCFTypeRef<SecKeychainSearchRef> search(
+      CrSKeychainSearchCreateFromAttributes(NULL, CSSM_DL_DB_RECORD_ANY, NULL));
 
-  base::mac::ScopedCFTypeRef<SecTrustedApplicationRef> this_application(
+  base::ScopedCFTypeRef<SecTrustedApplicationRef> this_application(
       CrSTrustedApplicationCreateFromPath(NULL));
 
   std::vector<std::string> requirement_matches =
       GetRequirementMatches(this_application);
 
   std::vector<CrSKeychainItemAndAccess> items_and_reauthorized_accesses =
       KCSearchToKCItemsAndReauthorizedAccesses(search,
                                                requirement_matches,
                                                this_application);
 
@@ skipping 34 matching lines @@
       UMA_HISTOGRAM_COUNTS("OSX.KeychainReauthorizeIfNeededAtUpdateSuccess",
                            pref_value);
     }
   }
 }
 
 namespace {
 
 std::string RequirementStringForApplication(
     SecTrustedApplicationRef application) {
-  base::mac::ScopedCFTypeRef<SecRequirementRef> requirement(
+  base::ScopedCFTypeRef<SecRequirementRef> requirement(
       CrSTrustedApplicationCopyRequirement(application));
-  base::mac::ScopedCFTypeRef<CFStringRef> requirement_string_cf(
+  base::ScopedCFTypeRef<CFStringRef> requirement_string_cf(
       CrSRequirementCopyString(requirement, kSecCSDefaultFlags));
   if (!requirement_string_cf) {
     return std::string();
   }
 
   std::string requirement_string =
       base::SysCFStringRefToUTF8(requirement_string_cf);
 
   return requirement_string;
 }
@@ skipping 97 matching lines @@
 
   return requirement_matches;
 }
 
 std::vector<CrSKeychainItemAndAccess> KCSearchToKCItemsAndReauthorizedAccesses(
     SecKeychainSearchRef search,
     const std::vector<std::string>& requirement_matches,
     SecTrustedApplicationRef this_application) {
   std::vector<CrSKeychainItemAndAccess> items_and_accesses;
 
-  base::mac::ScopedCFTypeRef<SecKeychainItemRef> item;
+  base::ScopedCFTypeRef<SecKeychainItemRef> item;
   while (item.reset(CrSKeychainSearchCopyNext(search)), item) {
     scoped_ptr<CrSKeychainItemAndAccess> item_and_access(
         KCItemToKCItemAndReauthorizedAccess(item,
                                             requirement_matches,
                                             this_application));
 
     if (item_and_access.get()) {
       items_and_accesses.push_back(*item_and_access);
     }
   }
 
   return items_and_accesses;
 }
 
 CrSKeychainItemAndAccess* KCItemToKCItemAndReauthorizedAccess(
     SecKeychainItemRef item,
     const std::vector<std::string>& requirement_matches,
     SecTrustedApplicationRef this_application) {
   if (!CrSKeychainItemTestAccess(item)) {
     return NULL;
   }
 
-  base::mac::ScopedCFTypeRef<SecAccessRef> access(
-      CrSKeychainItemCopyAccess(item));
-  base::mac::ScopedCFTypeRef<CFArrayRef> acl_list(
-      CrSAccessCopyACLList(access));
+  base::ScopedCFTypeRef<SecAccessRef> access(CrSKeychainItemCopyAccess(item));
+  base::ScopedCFTypeRef<CFArrayRef> acl_list(CrSAccessCopyACLList(access));
   if (!acl_list) {
     return NULL;
   }
 
   bool acl_list_modified = ReauthorizeACLList(acl_list,
                                               requirement_matches,
                                               this_application);
   if (!acl_list_modified) {
     return NULL;
   }
@@ skipping 99 matching lines @@
            items_and_reauthorized_accesses.begin();
        iterator != items_and_reauthorized_accesses.end();
        ++iterator) {
     WriteKCItemAndReauthorizedAccess(*iterator);
   }
 }
 
 void WriteKCItemAndReauthorizedAccess(
     const CrSKeychainItemAndAccess& item_and_reauthorized_access) {
   SecKeychainItemRef old_item = item_and_reauthorized_access.item();
-  base::mac::ScopedCFTypeRef<SecKeychainRef> keychain(
+  base::ScopedCFTypeRef<SecKeychainRef> keychain(
       CrSKeychainItemCopyKeychain(old_item));
 
   ScopedCrSKeychainItemAttributesAndData old_attributes_and_data(
       CrSKeychainItemCopyAttributesAndData(keychain, old_item));
   if (!old_attributes_and_data.get()) {
     return;
   }
 
   // CrSKeychainItemCreateFromContent (SecKeychainItemCreateFromContent)
   // returns errKCNoSuchAttr (errSecNoSuchAttr) when asked to add an item of
@@ skipping 36 matching lines @@
       *old_attributes_and_data.get();
   new_attributes_and_data.attribute_list = &new_attribute_list;
 
   // Delete the item last, to give everything else above a chance to bail
   // out early, and to ensure that the old item is still present while it
   // may still be used by the above code.
   if (!CrSKeychainItemDelete(old_item)) {
     return;
   }
 
-  base::mac::ScopedCFTypeRef<SecKeychainItemRef> new_item(
+  base::ScopedCFTypeRef<SecKeychainItemRef> new_item(
       CrSKeychainItemCreateFromContent(new_attributes_and_data,
                                        keychain,
                                        item_and_reauthorized_access.access()));
 }
 
 std::vector<SecKeychainAttribute> KCAttributesWithoutZeroLength(
     SecKeychainAttributeList* old_attribute_list) {
   UInt32 old_attribute_count = old_attribute_list->count;
   std::vector<SecKeychainAttribute> new_attributes;
   new_attributes.reserve(old_attribute_count);
   for (UInt32 old_attribute_index = 0;
        old_attribute_index < old_attribute_count;
        ++old_attribute_index) {
     SecKeychainAttribute* attribute =
         &old_attribute_list->attr[old_attribute_index];
     if (attribute->length) {
       new_attributes.push_back(*attribute);
     }
   }
 
   return new_attributes;
 }
 
 }  // namespace
 
 }  // namespace chrome