Fix memory leaks in RenderTextMac.

ui/gfx/render_text_mac.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 "ui/gfx/render_text_mac.h"
 
 #include <ApplicationServices/ApplicationServices.h>
 
 #include <cmath>
 #include <utility>
@@ skipping 137 matching lines @@
   return std::vector<Rect>();
 }
 
 bool RenderTextMac::IsCursorablePosition(size_t position) {
   // TODO(asvitkine): Implement this. http://crbug.com/131618
   return false;
 }
 
 void RenderTextMac::ResetLayout() {
   line_.reset();
+  attributes_.reset();
   runs_.clear();
   runs_valid_ = false;
 }
 
 void RenderTextMac::EnsureLayout() {
   if (line_.get())
     return;
   runs_.clear();
   runs_valid_ = false;
 
   const Font& font = GetFont();
   CTFontRef ct_font =
       CreateCTFontWithPixelSize(font.GetFontName(), font.GetFontSize());
 
   const void* keys[] = { kCTFontAttributeName };
   const void* values[] = { ct_font };
   base::mac::ScopedCFTypeRef<CFDictionaryRef> attributes(
-      CFDictionaryCreate(NULL, keys, values, arraysize(keys), NULL, NULL));
+      CFDictionaryCreate(NULL, keys, values, arraysize(keys), NULL,
+                         &kCFTypeDictionaryValueCallBacks));
 
   base::mac::ScopedCFTypeRef<CFStringRef> cf_text(
       base::SysUTF16ToCFStringRef(text()));
   base::mac::ScopedCFTypeRef<CFAttributedStringRef> attr_text(
       CFAttributedStringCreate(NULL, cf_text, attributes));
   base::mac::ScopedCFTypeRef<CFMutableAttributedStringRef> attr_text_mutable(
       CFAttributedStringCreateMutableCopy(NULL, 0, attr_text));
 
   ApplyStyles(attr_text_mutable, ct_font);
   line_.reset(CTLineCreateWithAttributedString(attr_text_mutable));
@@ skipping 35 matching lines @@
       font_style(Font::NORMAL),
       text_size(0),
       foreground(SK_ColorBLACK) {
 }
 
 RenderTextMac::TextRun::~TextRun() {
 }
 
 void RenderTextMac::ApplyStyles(CFMutableAttributedStringRef attr_string,
                                 CTFontRef font) {
+  // Clear attributes and reserve space to hold the maximum number of entries,
+  // which is at most three per style range per the code below.
+  attributes_.reset(CFArrayCreateMutable(NULL, 3 * style_ranges().size(),
+                                         &kCFTypeArrayCallBacks));
+
   // https://developer.apple.com/library/mac/#documentation/Carbon/Reference/CoreText_StringAttributes_Ref/Reference/reference.html
   for (size_t i = 0; i < style_ranges().size(); ++i) {
     const StyleRange& style = style_ranges()[i];
     const CFRange range = CFRangeMake(style.range.start(),
                                       style.range.length());
 
     // Note: CFAttributedStringSetAttribute() does not appear to retain the
-    // values passed in, as can be verified via CFGetRetainCount().
-    //
-    // TODO(asvitkine): The attributed string appears to hold weak refs to these
-    // objects (it does not release them either), so we need to keep track of
-    // them ourselves and release them at an appropriate time.
+    // values passed in, as can be verified via CFGetRetainCount(). To ensure
+    // the attribute objects do not leak, they are saved to |attributes_|.
 
-    CGColorRef foreground = gfx::SkColorToCGColorRef(style.foreground);
+    base::mac::ScopedCFTypeRef<CGColorRef> foreground(
+        gfx::CGColorCreateFromSkColor(style.foreground));
     CFAttributedStringSetAttribute(attr_string, range,
                                    kCTForegroundColorAttributeName,
                                    foreground);
+    CFArrayAppendValue(attributes_, foreground);
 
     if (style.underline) {
       CTUnderlineStyle value = kCTUnderlineStyleSingle;
-      CFNumberRef underline = CFNumberCreate(NULL, kCFNumberSInt32Type, &value);
+      base::mac::ScopedCFTypeRef<CFNumberRef> underline(
+          CFNumberCreate(NULL, kCFNumberSInt32Type, &value));
       CFAttributedStringSetAttribute(attr_string, range,
                                      kCTUnderlineStyleAttributeName,
                                      underline);
+      CFArrayAppendValue(attributes_, underline);
     }
 
     if (style.font_style & (Font::BOLD | Font::ITALIC)) {
       int traits = 0;
       if (style.font_style & Font::BOLD)
         traits |= kCTFontBoldTrait;
       if (style.font_style & Font::ITALIC)
         traits |= kCTFontItalicTrait;
-      CTFontRef styled_font =
-          CTFontCreateCopyWithSymbolicTraits(font, 0.0, NULL, traits, traits);
+      base::mac::ScopedCFTypeRef<CTFontRef> styled_font(
+          CTFontCreateCopyWithSymbolicTraits(font, 0.0, NULL, traits, traits));
       // TODO(asvitkine): Handle |styled_font| == NULL case better.
       if (styled_font) {
         CFAttributedStringSetAttribute(attr_string, range, kCTFontAttributeName,
                                        styled_font);
+        CFArrayAppendValue(attributes_, styled_font);
       }
     }
   }
 }
 
 void RenderTextMac::ComputeRuns() {
   DCHECK(line_);
 
   CFArrayRef ct_runs = CTLineGetGlyphRuns(line_);
   const CFIndex ct_runs_count = CFArrayGetCount(ct_runs);
@@ skipping 81 matching lines @@
     run_origin.offset(run_width, 0);
   }
   runs_valid_ = true;
 }
 
 RenderText* RenderText::CreateInstance() {
   return new RenderTextMac;
 }
 
 }  // namespace gfx