[ObjC ARC] Converts ios/chrome/browser/ui/util:util to ARC.

ios/chrome/browser/ui/util/manual_text_framer.mm

 // Copyright 2015 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.
 
 #import "ios/chrome/browser/ui/util/manual_text_framer.h"
 
 #import <UIKit/UIKit.h>
 
 #include "base/i18n/rtl.h"
 #include "base/logging.h"
 #include "base/mac/foundation_util.h"
-#include "base/mac/scoped_nsobject.h"
 #import "ios/chrome/browser/ui/util/core_text_util.h"
 #import "ios/chrome/browser/ui/util/text_frame.h"
 #import "ios/chrome/browser/ui/util/unicode_util.h"
 
+#if !defined(__has_feature) || !__has_feature(objc_arc)
+#error "This file requires ARC support."
+#endif
+
 // NOTE: When RTL text is laid out into glyph runs, the glyphs appear in the
 // visual order in which they appear on screen.  In other words, the glyphs are
 // arranged in the reverse order of their corresponding characters in the
 // original string.
 
 namespace {
 // Aligns |value| to the nearest pixel value, rounding by the function indicated
 // by |function|.  AlignmentFunction::CEIL should be used to align size values,
 // while AlignmentFunction::FLOOR should be used to align location values.
 enum class AlignmentFunction : short { CEIL = 0, FLOOR };
@@ skipping 36 matching lines @@
   }
   return paragraph_strings;
 }
 }  // namespace
 
 #pragma mark - ManualTextFrame
 
 // A TextFrame implementation that is manually created by ManualTextFramer.
 @interface ManualTextFrame : NSObject<TextFrame> {
   // Backing objects for properties of the same name.
-  base::scoped_nsobject<NSAttributedString> _string;
-  base::scoped_nsobject<NSMutableArray> _lines;
+  NSAttributedString* _string;
+  NSMutableArray* _lines;
 }
 
 // Designated initializer.
 - (instancetype)initWithString:(NSAttributedString*)string
                       inBounds:(CGRect)bounds NS_DESIGNATED_INITIALIZER;
 - (instancetype)init NS_UNAVAILABLE;
 
 // Creates a FramedLine out of |line|, |stringRange|, and |origin|, then adds it
 // to |lines|.
 - (void)addFramedLineWithLine:(CTLineRef)line
                   stringRange:(NSRange)stringRange
                        origin:(CGPoint)origin;
 
 // Redefine property as readwrite.
 @property(nonatomic, readwrite) NSRange framedRange;
 
 @end
 
 @implementation ManualTextFrame
 
 @synthesize framedRange = _framedRange;
 @synthesize bounds = _bounds;
 
 - (instancetype)initWithString:(NSAttributedString*)string
                       inBounds:(CGRect)bounds {
   if ((self = [super init])) {
     DCHECK(string.string.length);
-    _string.reset([string retain]);
+    _string = string;
     _bounds = bounds;
-    _lines.reset([[NSMutableArray alloc] init]);
+    _lines = [[NSMutableArray alloc] init];
   }
   return self;
 }
 
 #pragma mark Accessors
 
 - (NSAttributedString*)string {
-  return _string.get();
+  return _string;
 }
 
 - (NSArray*)lines {
-  return _lines.get();
+  return _lines;
 }
 
 #pragma mark Private
 
 - (void)addFramedLineWithLine:(CTLineRef)line
                   stringRange:(NSRange)stringRange
                        origin:(CGPoint)origin {
-  base::scoped_nsobject<FramedLine> framedLine([[FramedLine alloc]
-      initWithLine:line
-       stringRange:stringRange
-            origin:origin]);
+  FramedLine* framedLine = [[FramedLine alloc] initWithLine:line
+                                                stringRange:stringRange
+                                                     origin:origin];
   [_lines addObject:framedLine];
 }
 
 @end
 
 #pragma mark - ManualTextFramer Private Interface
 
-@interface ManualTextFramer () {
-  // Backing objects for properties of the same name.
-  base::scoped_nsobject<NSAttributedString> _string;
-  base::scoped_nsobject<ManualTextFrame> _manualTextFrame;
-}
+@interface ManualTextFramer ()
 
 // The string passed upon initialization.
-@property(nonatomic, readonly) NSAttributedString* string;
+@property(strong, nonatomic, readonly) NSAttributedString* string;
 
 // The bounds passed upon initialization.
 @property(nonatomic, readonly) CGRect bounds;
 
 // The width of the bounds passed upon initialization.
 @property(nonatomic, readonly) CGFloat boundingWidth;
 
 // The remaining height into which text can be framed.
 @property(nonatomic, assign) CGFloat remainingHeight;
 
 // The text frame constructed by |-frameText|.
-@property(nonatomic, readonly) ManualTextFrame* manualTextFrame;
+@property(strong, nonatomic, readonly) ManualTextFrame* manualTextFrame;
 
 // Creates a ManualTextFrame and assigns it to |_manualTextFrame|.  Returns YES
 // if a new text frame was successfully created.
 - (BOOL)setupManualTextFrame;
 
 @end
 
 #pragma mark - ParagraphFramer
 
 // ManualTextFramer subclass that frames a single paragraph.  A paragraph is
 // defined as an NSAttributedString which contains either zero newlines or one
 // newline as its last character.
 @interface ParagraphFramer : ManualTextFramer {
   // Backing objects for properties of the same name.
   base::ScopedCFTypeRef<CTLineRef> _line;
-  base::scoped_nsobject<NSCharacterSet> _lineEndSet;
 }
 
 // The CTLine created from |string|.
 @property(nonatomic, readonly) CTLineRef line;
 
 // The effective text alignment for |line|.
 @property(nonatomic, readonly) NSTextAlignment effectiveAlignment;
 
 // Character set containing characters that are appropriate for line endings.
 // These characters include whitespaces and newlines (denoting a word boundary),
 // in addition to line-ending characters like hyphens, em dashes, and en dashes.
-@property(nonatomic, readonly) NSCharacterSet* lineEndSet;
+@property(strong, nonatomic, readonly) NSCharacterSet* lineEndSet;
 
 // The index of the current run that is being framed.  Setting |runIdx| also
 // updates |currentRun| and |currentGlyphCount|.
 @property(nonatomic, assign) CFIndex runIdx;
 
 // The CTRun corresponding with |runIdx| in |line|.
 @property(nonatomic, readonly) CTRunRef currentRun;
 
 // The glyph count in |currentRun|.
 @property(nonatomic, readonly) CFIndex currentGlyphCount;
@@ skipping 71 matching lines @@
 
 @synthesize effectiveAlignment = _effectiveTextAlignment;
 @synthesize runIdx = _runIdx;
 @synthesize currentRun = _currentRun;
 @synthesize currentGlyphCount = _currentGlyphCount;
 @synthesize framedGlyphCount = _framedGlyphCount;
 @synthesize currentLineRange = _currentLineRange;
 @synthesize currentLineWidth = _currentLineWidth;
 @synthesize currentWhitespaceWidth = _currentWhitespaceWidth;
 @synthesize isRTL = _isRTL;
+@synthesize lineEndSet = _lineEndSet;
 
 - (instancetype)initWithString:(NSAttributedString*)string
                       inBounds:(CGRect)bounds {
   if ((self = [super initWithString:string inBounds:bounds])) {
     NSRange newlineRange = [string.string
         rangeOfCharacterFromSet:[NSCharacterSet newlineCharacterSet]];
     DCHECK(newlineRange.location == NSNotFound ||
            newlineRange.location == string.string.length - 1);
     CTLineRef line =
         CTLineCreateWithAttributedString(base::mac::NSToCFCast(string));
@@ skipping 52 matching lines @@
 
 - (CTLineRef)line {
   return _line.get();
 }
 
 - (NSCharacterSet*)lineEndSet {
   if (!_lineEndSet) {
     NSMutableCharacterSet* lineEndSet =
         [NSMutableCharacterSet whitespaceAndNewlineCharacterSet];
     [lineEndSet addCharactersInString:@"-\u2013\u2014"];
-    _lineEndSet.reset([lineEndSet retain]);
+    _lineEndSet = lineEndSet;
   }
   return _lineEndSet;
 }
 
 - (void)setRunIdx:(CFIndex)runIdx {
   _runIdx = runIdx;
   self.framedGlyphCount = 0;
   if ([self runIdxIsValid:runIdx]) {
     NSArray* runs = base::mac::CFToNSCast(CTLineGetGlyphRuns(self.line));
-    _currentRun = static_cast<CTRunRef>(runs[_runIdx]);
+    _currentRun = (__bridge CTRunRef)(runs[_runIdx]);
     _currentGlyphCount = CTRunGetGlyphCount(self.currentRun);
   } else {
     _currentRun = nullptr;
     _currentGlyphCount = 0;
   }
 }
 
 - (CFIndex)incrementAmount {
   return self.isRTL ? -1 : 1;
 }
@@ skipping 188 matching lines @@
 
 @end
 
 #pragma mark - ManualTextFramer
 
 @implementation ManualTextFramer
 
 @synthesize bounds = _bounds;
 @synthesize boundingWidth = _boundingWidth;
 @synthesize remainingHeight = _remainingHeight;
+@synthesize string = _string;
+@synthesize manualTextFrame = _manualTextFrame;
 
 - (instancetype)initWithString:(NSAttributedString*)string
                       inBounds:(CGRect)bounds {
   if ((self = [super init])) {
     DCHECK(string.string.length);
-    _string.reset([string retain]);
+    _string = string;
     _bounds = bounds;
     _boundingWidth = CGRectGetWidth(bounds);
     _remainingHeight = CGRectGetHeight(bounds);
   }
   return self;
 }
 
 - (void)frameText {
   if (![self setupManualTextFrame])
     return;
   NSRange framedRange = NSMakeRange(0, 0);
   NSArray* paragraphs = GetParagraphStringsForString(self.string);
   NSUInteger stringRangeOffset = 0;
   for (NSAttributedString* paragraph in paragraphs) {
     // Frame each paragraph using a ParagraphFramer, then update bookkeeping
     // variables for the top-level ManualTextFramer.
     CGRect remainingBounds =
         CGRectMake(0, 0, self.boundingWidth, self.remainingHeight);
-    base::scoped_nsobject<ParagraphFramer> framer([[ParagraphFramer alloc]
-        initWithString:paragraph
-              inBounds:remainingBounds]);
+    ParagraphFramer* framer =
+        [[ParagraphFramer alloc] initWithString:paragraph
+                                       inBounds:remainingBounds];
     [framer frameText];
     id<TextFrame> frame = [framer textFrame];
     DCHECK(frame);
     framedRange.length += frame.framedRange.length;
     CGFloat paragraphHeight = 0.0;
     for (FramedLine* line in frame.lines) {
       NSRange lineRange = line.stringRange;
       lineRange.location += stringRangeOffset;
       [self.manualTextFrame addFramedLineWithLine:line.line
                                       stringRange:lineRange
                                            origin:line.origin];
       paragraphHeight += core_text_util::GetLineHeight(self.string, lineRange) +
                          core_text_util::GetLineSpacing(self.string, lineRange);
     }
     self.remainingHeight -= paragraphHeight;
     stringRangeOffset += paragraph.string.length;
   }
   self.manualTextFrame.framedRange = framedRange;
 }
 
 #pragma mark Accessors
 
-- (NSAttributedString*)string {
-  return _string.get();
-}
-
-- (ManualTextFrame*)manualTextFrame {
-  return _manualTextFrame.get();
-}
-
 - (id<TextFrame>)textFrame {
-  return _manualTextFrame.get();
+  return _manualTextFrame;
 }
 
 #pragma mark Private
 
 - (BOOL)setupManualTextFrame {
   if (_manualTextFrame)
     return NO;
-  _manualTextFrame.reset([[ManualTextFrame alloc] initWithString:self.string
-                                                        inBounds:self.bounds]);
+  _manualTextFrame =
+      [[ManualTextFrame alloc] initWithString:self.string inBounds:self.bounds];
   return YES;
 }
 
 @end