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

content/renderer/pepper/pepper_truetype_font_mac.mm

 // Copyright (c) 2013 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 "content/renderer/pepper/pepper_truetype_font.h"
 
 #import <ApplicationServices/ApplicationServices.h>
 
 #include <stdio.h>
 
@@ skipping 96 matching lines @@
   virtual int32_t GetTableTags(std::vector<uint32_t>* tags) OVERRIDE;
   virtual int32_t GetTable(uint32_t table_tag,
                            int32_t offset,
                            int32_t max_data_length,
                            std::string* data) OVERRIDE;
  private:
   virtual int32_t GetEntireFont(int32_t offset,
                                 int32_t max_data_length,
                                 std::string* data);
 
-  base::mac::ScopedCFTypeRef<CTFontRef> font_ref_;
+  base::ScopedCFTypeRef<CTFontRef> font_ref_;
 
   DISALLOW_COPY_AND_ASSIGN(PepperTrueTypeFontMac);
 };
 
 PepperTrueTypeFontMac::PepperTrueTypeFontMac(
     const ppapi::proxy::SerializedTrueTypeFontDesc& desc) {
   // Create attributes and traits dictionaries.
-  base::mac::ScopedCFTypeRef<CFMutableDictionaryRef> attributes_ref(
-      CFDictionaryCreateMutable(kCFAllocatorDefault, 0,
+  base::ScopedCFTypeRef<CFMutableDictionaryRef> attributes_ref(
+      CFDictionaryCreateMutable(kCFAllocatorDefault,
+                                0,
                                 &kCFTypeDictionaryKeyCallBacks,
                                 &kCFTypeDictionaryValueCallBacks));
 
-  base::mac::ScopedCFTypeRef<CFMutableDictionaryRef> traits_ref(
-      CFDictionaryCreateMutable(kCFAllocatorDefault, 0,
+  base::ScopedCFTypeRef<CFMutableDictionaryRef> traits_ref(
+      CFDictionaryCreateMutable(kCFAllocatorDefault,
+                                0,
                                 &kCFTypeDictionaryKeyCallBacks,
                                 &kCFTypeDictionaryValueCallBacks));
   if (!attributes_ref || !traits_ref)
     return;
 
   CFDictionaryAddValue(attributes_ref, kCTFontTraitsAttribute, traits_ref);
 
   // Use symbolic traits to specify traits when possible.
   CTFontSymbolicTraits symbolic_traits = 0;
   if (desc.style & PP_TRUETYPEFONTSTYLE_ITALIC)
     symbolic_traits |= kCTFontItalicTrait;
   if (desc.weight == PP_TRUETYPEFONTWEIGHT_BOLD)
     symbolic_traits |= kCTFontBoldTrait;
   if (desc.width == PP_TRUETYPEFONTWIDTH_CONDENSED)
     symbolic_traits |= kCTFontCondensedTrait;
   else if (desc.width == PP_TRUETYPEFONTWIDTH_EXPANDED)
     symbolic_traits |= kCTFontExpandedTrait;
 
-  base::mac::ScopedCFTypeRef<CFNumberRef> symbolic_traits_ref(
-      CFNumberCreate(kCFAllocatorDefault,
-                     kCFNumberSInt32Type,
-                     &symbolic_traits));
+  base::ScopedCFTypeRef<CFNumberRef> symbolic_traits_ref(CFNumberCreate(
+      kCFAllocatorDefault, kCFNumberSInt32Type, &symbolic_traits));
   if (!symbolic_traits_ref)
     return;
   CFDictionaryAddValue(traits_ref, kCTFontSymbolicTrait, symbolic_traits_ref);
 
   // Font family matching doesn't work using family classes in symbolic traits.
   // Instead, map generic_family to font families that are always available.
   std::string family(desc.family);
   if (family.empty()) {
     switch (desc.generic_family) {
       case PP_TRUETYPEFONTFAMILY_SERIF:
         family = "Times";
         break;
       case PP_TRUETYPEFONTFAMILY_SANSSERIF:
         family = "Helvetica";
         break;
       case PP_TRUETYPEFONTFAMILY_CURSIVE:
         family = "Apple Chancery";
         break;
       case PP_TRUETYPEFONTFAMILY_FANTASY:
         family = "Papyrus";
         break;
       case PP_TRUETYPEFONTFAMILY_MONOSPACE:
         family = "Courier";
         break;
     }
   }
 
-  base::mac::ScopedCFTypeRef<CFStringRef> name_ref(
+  base::ScopedCFTypeRef<CFStringRef> name_ref(
       base::SysUTF8ToCFStringRef(family));
   if (name_ref)
     CFDictionaryAddValue(attributes_ref, kCTFontFamilyNameAttribute, name_ref);
 
   if (desc.weight != PP_TRUETYPEFONTWEIGHT_NORMAL &&
       desc.weight != PP_TRUETYPEFONTWEIGHT_BOLD) {
     float weight = GetMacWeight(desc.weight);
-    base::mac::ScopedCFTypeRef<CFNumberRef> weight_trait_ref(
-        CFNumberCreate(kCFAllocatorDefault,
-                       kCFNumberFloat32Type,
-                       &weight));
+    base::ScopedCFTypeRef<CFNumberRef> weight_trait_ref(
+        CFNumberCreate(kCFAllocatorDefault, kCFNumberFloat32Type, &weight));
     if (weight_trait_ref)
       CFDictionaryAddValue(traits_ref, kCTFontWeightTrait, weight_trait_ref);
   }
 
   if (desc.width != PP_TRUETYPEFONTWIDTH_NORMAL &&
       desc.width != PP_TRUETYPEFONTWIDTH_CONDENSED &&
       desc.width != PP_TRUETYPEFONTWIDTH_EXPANDED) {
     float width = GetMacWidth(desc.width);
-    base::mac::ScopedCFTypeRef<CFNumberRef> width_trait_ref(
-        CFNumberCreate(kCFAllocatorDefault,
-                       kCFNumberFloat32Type,
-                       &width));
+    base::ScopedCFTypeRef<CFNumberRef> width_trait_ref(
+        CFNumberCreate(kCFAllocatorDefault, kCFNumberFloat32Type, &width));
     if (width_trait_ref)
       CFDictionaryAddValue(traits_ref, kCTFontWidthTrait, width_trait_ref);
   }
 
-  base::mac::ScopedCFTypeRef<CTFontDescriptorRef> desc_ref(
+  base::ScopedCFTypeRef<CTFontDescriptorRef> desc_ref(
       CTFontDescriptorCreateWithAttributes(attributes_ref));
 
   if (desc_ref)
     font_ref_.reset(CTFontCreateWithFontDescriptor(desc_ref, 0, NULL));
 }
 
 PepperTrueTypeFontMac::~PepperTrueTypeFontMac() {
 }
 
 bool PepperTrueTypeFontMac::IsValid() {
   return font_ref_.get() != NULL;
 }
 
 int32_t PepperTrueTypeFontMac::Describe(
     ppapi::proxy::SerializedTrueTypeFontDesc* desc) {
   if (!IsValid())
     return PP_ERROR_FAILED;
 
-  base::mac::ScopedCFTypeRef<CTFontDescriptorRef> desc_ref(
+  base::ScopedCFTypeRef<CTFontDescriptorRef> desc_ref(
       CTFontCopyFontDescriptor(font_ref_));
 
-  base::mac::ScopedCFTypeRef<CFStringRef> family_name_ref(
-      base::mac::CFCast<CFStringRef>(CTFontDescriptorCopyAttribute(
-          desc_ref, kCTFontFamilyNameAttribute)));
+  base::ScopedCFTypeRef<CFStringRef> family_name_ref(
+      base::mac::CFCast<CFStringRef>(
+          CTFontDescriptorCopyAttribute(desc_ref, kCTFontFamilyNameAttribute)));
   desc->family = base::SysCFStringRefToUTF8(family_name_ref);
 
-  base::mac::ScopedCFTypeRef<CFDictionaryRef> traits_ref(
+  base::ScopedCFTypeRef<CFDictionaryRef> traits_ref(
       base::mac::CFCast<CFDictionaryRef>(
           CTFontDescriptorCopyAttribute(desc_ref, kCTFontTraitsAttribute)));
 
   desc->style = PP_TRUETYPEFONTSTYLE_NORMAL;
   CTFontSymbolicTraits symbolic_traits(CTFontGetSymbolicTraits(font_ref_));
   if (symbolic_traits & kCTFontItalicTrait)
     desc->style = static_cast<PP_TrueTypeFontStyle_Dev>(
                       desc->style | PP_TRUETYPEFONTSTYLE_ITALIC);
   if (symbolic_traits & kCTFontBoldTrait) {
     desc->weight = PP_TRUETYPEFONTWEIGHT_BOLD;
@@ skipping 11 matching lines @@
     if (FindFloat(traits_ref, kCTFontWidthTrait, &width))
       desc->width = GetPepperWidth(width);
   }
 
   // Character set isn't supported on Mac.
   desc->charset = PP_TRUETYPEFONTCHARSET_DEFAULT;
   return PP_OK;
 }
 
 int32_t PepperTrueTypeFontMac::GetTableTags(std::vector<uint32_t>* tags) {
-  base::mac::ScopedCFTypeRef<CFArrayRef> tag_array(
+  base::ScopedCFTypeRef<CFArrayRef> tag_array(
       CTFontCopyAvailableTables(font_ref_, kCTFontTableOptionNoOptions));
   if (!tag_array)
     return PP_ERROR_FAILED;
 
   // Items returned by CTFontCopyAvailableTables are not boxed. Whose bright
   // idea was this?
   CFIndex length = CFArrayGetCount(tag_array);
   tags->resize(length);
   for (CFIndex i = 0; i < length; ++i) {
     (*tags)[i] =
         reinterpret_cast<uintptr_t>(CFArrayGetValueAtIndex(tag_array, i));
   }
   return length;
 }
 
 int32_t PepperTrueTypeFontMac::GetTable(uint32_t table_tag,
                                         int32_t offset,
                                         int32_t max_data_length,
                                         std::string* data) {
   if (!table_tag)
     return GetEntireFont(offset, max_data_length, data);
 
-  base::mac::ScopedCFTypeRef<CFDataRef> table_ref(
-      CTFontCopyTable(font_ref_, static_cast<CTFontTableTag>(table_tag),
+  base::ScopedCFTypeRef<CFDataRef> table_ref(
+      CTFontCopyTable(font_ref_,
+                      static_cast<CTFontTableTag>(table_tag),
                       kCTFontTableOptionNoOptions));
   if (!table_ref)
     return PP_ERROR_FAILED;
 
   CFIndex table_size = CFDataGetLength(table_ref);
   CFIndex safe_offset =
       std::min(base::checked_numeric_cast<CFIndex>(offset), table_size);
   CFIndex safe_length =
       std::min(table_size - safe_offset,
                base::checked_numeric_cast<CFIndex>(max_data_length));
@@ skipping 10 matching lines @@
   // Reconstruct the font header, table directory, and tables.
   std::vector<uint32_t> table_tags;
   int32_t table_count = GetTableTags(&table_tags);
   if (table_count < 0)
     return table_count;  // PPAPI error code.
 
   // Allocate enough room for the header and the table directory entries.
   std::string font(sizeof(FontHeader) +
                    sizeof(FontDirectoryEntry) * table_count, 0);
   // Map the OS X font type value to a TrueType scalar type.
-  base::mac::ScopedCFTypeRef<CFNumberRef> font_type_ref(
+  base::ScopedCFTypeRef<CFNumberRef> font_type_ref(
       base::mac::CFCast<CFNumberRef>(
           CTFontCopyAttribute(font_ref_, kCTFontFormatAttribute)));
   int32_t font_type;
   CFNumberGetValue(font_type_ref, kCFNumberSInt32Type, &font_type);
   switch (font_type) {
     case kCTFontFormatOpenTypePostScript:
       font_type = MAKE_TABLE_TAG('O', 'T', 'T', 'O');
       break;
     case kCTFontFormatTrueType:
     case kCTFontFormatBitmap:
@@ skipping 68 matching lines @@
 
 }  // namespace
 
 // static
 PepperTrueTypeFont* PepperTrueTypeFont::Create(
     const ppapi::proxy::SerializedTrueTypeFontDesc& desc) {
   return new PepperTrueTypeFontMac(desc);
 }
 
 }  // namespace content