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

ios/chrome/browser/ui/stack_view/card_stack_layout_manager.mm

 // Copyright 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.
 
 #import "ios/chrome/browser/ui/stack_view/card_stack_layout_manager.h"
 
 #include <algorithm>
 #include <cmath>
 
 #include "base/logging.h"
 #include "ios/chrome/browser/ui/rtl_geometry.h"
+#import "ios/chrome/browser/ui/stack_view/card_view.h"
 #import "ios/chrome/browser/ui/stack_view/stack_card.h"
+#import "ios/chrome/browser/ui/stack_view/title_label.h"
 #import "ios/chrome/browser/ui/ui_util.h"
 
+#if !defined(__has_feature) || !__has_feature(objc_arc)
+#error "This file requires ARC support."
+#endif
+
 namespace {
 
 // The maximum number of cards that should be staggered at a collapse point.
 const NSInteger kMaxVisibleStaggerCount = 4;
 // The amount that each of the staggered cards in a stack should be staggered
 // when fully collapsed.
 const CGFloat kMinStackStaggerAmount = 4.0;
 // The amount that a card should overlap with a previous/subsequent card when
 // it is extended the maximum distance away (e.g., after a multitouch event).
 const CGFloat kFullyExtendedCardOverlap = 8.0;
 // The amount that a card's position is allowed to drift toward overextension
 // before the card is considered to be overextended (i.e., an epsilon to allow
 // for floating-point imprecision).
 const CGFloat kDistanceBeforeOverextension = 0.0001;
 // The factor by which scroll is decayed on overscroll.
 const CGFloat kOverextensionDecayFactor = 2.0;
 // The amount by which a card is scrolled when asked to scroll it away from its
 // preceding neighbor.
 const CGFloat kScrollAwayFromNeighborAmount = 200;
 
 }  // namespace
 
-@interface CardStackLayoutManager ()
+@interface CardStackLayoutManager () {
+  NSMutableArray* cards_;
+  // YES if the previous call to one of {|scrollCardAtIndex|,
+  // |handleMultitouchWithFirstDelta|} was to the former method; NO otherwise.
+  BOOL treatOverExtensionAsScroll_;
+  NSUInteger previousFirstPinchCardIndex_;
+  NSUInteger previousSecondPinchCardIndex_;
+}
 
 // Exposes |kMinStackStaggerAmount| for tests.
 - (CGFloat)minStackStaggerAmount;
 // Exposes |kScrollAwayFromNeighborAmount| for tests.
 - (CGFloat)scrollCardAwayFromNeighborAmount;
 // Returns the current start stack limit allowing for overextension as follows:
 // - If the card at |index| is not overextended toward the start, returns
 // |startLimit_|.
 // - Otherwise, returns the value of the start limit such that the position of
 // the card at |index| in the start stack is its current position (with the
@@ skipping 139 matching lines @@
 @synthesize maximumOverextensionAmount = maximumOverextensionAmount_;
 @synthesize endLimit = endLimit_;
 @synthesize layoutAxisPosition = layoutAxisPosition_;
 @synthesize startLimit = startLimit_;
 @synthesize layoutIsVertical = layoutIsVertical_;
 @synthesize lastStartStackCardIndex = lastStartStackCardIndex_;
 @synthesize firstEndStackCardIndex = firstEndStackCardIndex_;
 
 - (id)init {
   if ((self = [super init])) {
-    cards_.reset([[NSMutableArray alloc] init]);
+    cards_ = [[NSMutableArray alloc] init];
     layoutIsVertical_ = YES;
     lastStartStackCardIndex_ = -1;
     firstEndStackCardIndex_ = -1;
   }
   return self;
 }
 
 - (CGFloat)minStackStaggerAmount {
   return kMinStackStaggerAmount;
 }
@@ skipping 32 matching lines @@
   lastStartStackCardIndex_ = -1;
   firstEndStackCardIndex_ = -1;
   [cards_ removeAllObjects];
 }
 
 - (void)setCardSize:(CGSize)size {
   cardSize_ = size;
   NSUInteger i = 0;
   CGFloat previousFirstCardOffset = 0;
   CGFloat newFirstCardOffset = 0;
-  for (StackCard* card in cards_.get()) {
+  for (StackCard* card in cards_) {
     CGFloat offset = [self cardOffsetOnLayoutAxis:card];
     card.size = cardSize_;
     CGFloat newOffset = offset;
 
     // Attempt to preserve card positions, but ensure that the deck starts
     // within overextension limits and that all cards not in the start stack are
     // within minimum/maximum separation limits of their preceding neighbors.
     if (i == 0) {
       newOffset = std::max(newOffset, [self limitOfOverextensionTowardStart]);
       newOffset = std::min(newOffset, [self limitOfOverscrollTowardEnd]);
@@ skipping 21 matching lines @@
   for (NSUInteger i = 0; i < [cards_ count]; i++) {
     LayoutRectPosition position = [[cards_ objectAtIndex:i] layout].position;
     CGFloat prevLayoutAxisOffset =
         layoutIsVertical_ ? position.leading : position.originY;
     [self moveOriginOfCardAtIndex:i toOffset:prevLayoutAxisOffset];
   }
 }
 
 - (void)setLayoutAxisPosition:(CGFloat)position {
   layoutAxisPosition_ = position;
-  for (StackCard* card in cards_.get()) {
+  for (StackCard* card in cards_) {
     LayoutRect layout = card.layout;
     if (layoutIsVertical_)
       layout.position.leading = position - 0.5 * layout.size.width;
     else
       layout.position.originY = position - 0.5 * layout.size.height;
     card.layout = layout;
   }
 }
 
 - (NSArray*)cards {
@@ skipping 818 matching lines @@
     CGFloat edgeOffset = endLimit_ - labelOffset;
     return cardOffset >= edgeOffset;
   } else {
     CGFloat separation =
         [self distanceBetweenCardAtIndex:index andCardAtIndex:(index + 1)];
     return separation <= labelOffset;
   }
 }
 
 - (void)setSynchronizeCardViews:(BOOL)synchronizeViews {
-  for (StackCard* card in cards_.get()) {
+  for (StackCard* card in cards_) {
     card.synchronizeView = synchronizeViews;
   }
 }
 
 - (BOOL)isInStartStack:(NSUInteger)index {
   DCHECK(index < [cards_ count]);
   return ((NSInteger)index <= lastStartStackCardIndex_);
 }
 
 - (BOOL)isInEndStack:(NSUInteger)index {
@@ skipping 46 matching lines @@
     return 0;
   return std::abs([self cardOffsetOnLayoutAxis:[cards_ firstObject]] -
                   startLimit_);
 }
 
 - (NSUInteger)fannedStackCount {
   return floor((endLimit_ - startLimit_) / maxStagger_);
 }
 
 @end