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

ios/chrome/browser/ui/stack_view/card_set.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_set.h"
 
 #import <QuartzCore/QuartzCore.h>
 
 #include "base/logging.h"
+#import "base/mac/scoped_nsobject.h"
 #import "ios/chrome/browser/tabs/tab.h"
 #import "ios/chrome/browser/tabs/tab_model.h"
 #include "ios/chrome/browser/ui/rtl_geometry.h"
 #import "ios/chrome/browser/ui/stack_view/card_stack_layout_manager.h"
 #import "ios/chrome/browser/ui/stack_view/page_animation_util.h"
 #import "ios/chrome/browser/ui/stack_view/stack_card.h"
 #include "ios/chrome/browser/ui/ui_util.h"
 #import "ios/web/web_state/ui/crw_web_controller.h"
 
-#if !defined(__has_feature) || !__has_feature(objc_arc)
-#error "This file requires ARC support."
-#endif
-
 namespace {
 const CGFloat kMaxCardStaggerPercentage = 0.35;
 }
 
 @interface CardSet ()<StackCardViewProvider, TabModelObserver> {
-  TabModel* tabModel_;
-  UIView* view_;
-  CardStackLayoutManager* stackModel_;
-  UIImageView* stackShadow_;
+  base::scoped_nsobject<TabModel> tabModel_;
+  base::scoped_nsobject<UIView> view_;
+  base::scoped_nsobject<CardStackLayoutManager> stackModel_;
+  base::scoped_nsobject<UIImageView> stackShadow_;
 }
 
 // Set to |YES| when the card set should draw a shadow around the entire stack.
 @property(nonatomic, assign) BOOL shouldShowShadow;
 
 // Creates and returns an autoreleased StackCard from the given |tab| (which
 // must not be nil).
 - (StackCard*)buildCardFromTab:(Tab*)tab;
 
 // Rebuilds the set of cards from the current state of the tab model.
@@ skipping 15 matching lines @@
 @implementation CardSet
 
 @synthesize observer = observer_;
 @synthesize ignoresTabModelChanges = ignoresTabModelChanges_;
 @synthesize defersCardHiding = defersCardHiding_;
 @synthesize keepOnlyVisibleCardViewsAlive = keepOnlyVisibleCardViewsAlive_;
 @synthesize shouldShowShadow = shouldShowShadow_;
 @synthesize closingCard = closingCard_;
 
 - (CardStackLayoutManager*)stackModel {
-  return stackModel_;
+  return stackModel_.get();
 }
 
 - (id)initWithModel:(TabModel*)model {
   if ((self = [super init])) {
-    tabModel_ = model;
+    tabModel_.reset([model retain]);
     [tabModel_ addObserver:self];
-    stackModel_ = [[CardStackLayoutManager alloc] init];
+    stackModel_.reset([[CardStackLayoutManager alloc] init]);
     [self rebuildCards];
     self.shouldShowShadow = YES;
   }
   return self;
 }
 
 - (void)dealloc {
   [tabModel_ removeObserver:self];
+  [super dealloc];
 }
 
 #pragma mark Properties
 
 - (TabModel*)tabModel {
   return tabModel_;
 }
 
 - (void)setTabModel:(TabModel*)tabModel {
   DCHECK([tabModel count] == 0);
   DCHECK([tabModel_ count] == 0);
   [tabModel_ removeObserver:self];
-  tabModel_ = tabModel;
+  tabModel_.reset([tabModel retain]);
   if (!ignoresTabModelChanges_)
     [tabModel_ addObserver:self];
 }
 
 - (NSArray*)cards {
   return [stackModel_ cards];
 }
 
 - (StackCard*)currentCard {
   DCHECK(!ignoresTabModelChanges_);
@@ skipping 11 matching lines @@
 }
 
 - (void)setCurrentCard:(StackCard*)card {
   DCHECK(!ignoresTabModelChanges_);
   NSInteger cardIndex = [self.cards indexOfObject:card];
   DCHECK(cardIndex != NSNotFound);
   [tabModel_ setCurrentTab:[tabModel_ tabAtIndex:cardIndex]];
 }
 
 - (UIView*)displayView {
-  return view_;
+  return view_.get();
 }
 
 - (void)setDisplayView:(UIView*)view {
-  if (view == view_)
+  if (view == view_.get())
     return;
   for (StackCard* card in self.cards) {
     if (card.viewIsLive) {
       [card.view removeFromSuperview];
       [card releaseView];
     }
   }
   [stackShadow_ removeFromSuperview];
-  view_ = view;
+  view_.reset([view retain]);
   // Add the stack shadow view to the new display view.
   if (!stackShadow_) {
     UIImage* shadowImage = [UIImage imageNamed:kCardShadowImageName];
     shadowImage = [shadowImage
         resizableImageWithCapInsets:UIEdgeInsetsMake(
                                         shadowImage.size.height / 2.0,
                                         shadowImage.size.width / 2.0,
                                         shadowImage.size.height / 2.0,
                                         shadowImage.size.width / 2.0)];
-    stackShadow_ = [[UIImageView alloc] initWithImage:shadowImage];
+    stackShadow_.reset([[UIImageView alloc] initWithImage:shadowImage]);
     [stackShadow_ setHidden:!self.cards.count];
   }
   [view_ addSubview:stackShadow_];
   // Don't set the stack's end limit when the view is set to nil in order to
   // avoid losing existing card positions; these positions will be needed
   // if/when the view is restored (e.g., if the view was purged due to a memory
   // warning while in a modal view and then restored when exiting the modal
   // view).
-  if (view_)
+  if (view_.get())
     [self displayViewSizeWasChanged];
 }
 
 - (CardCloseButtonSide)closeButtonSide {
   return [stackModel_ layoutIsVertical] ? CardCloseButtonSide::TRAILING
                                         : CardCloseButtonSide::LEADING;
 }
 
 - (void)setIgnoresTabModelChanges:(BOOL)ignoresTabModelChanges {
   if (ignoresTabModelChanges_ == ignoresTabModelChanges)
@@ skipping 229 matching lines @@
       // associated with this target to be removed. Note that if |object| is
       // not a target of |recognizer| this method is a no-op.
       [recognizer removeTarget:object action:NULL];
     }
   }
 }
 
 - (void)removeCardAtIndex:(NSUInteger)index {
   DCHECK(index < [self.cards count]);
   StackCard* card = [self.cards objectAtIndex:index];
+  [[card retain] autorelease];
   [self.observer cardSet:self willRemoveCard:card atIndex:index];
   [stackModel_ removeCard:card];
 
   [self.observer cardSet:self didRemoveCard:card atIndex:index];
 }
 
 #pragma mark Card Construction/Display
 
 - (StackCard*)buildCardFromTab:(Tab*)tab {
   DCHECK(tab);
-  StackCard* card = [[StackCard alloc] initWithViewProvider:self];
+  StackCard* card = [[[StackCard alloc] initWithViewProvider:self] autorelease];
   card.size = [stackModel_ cardSize];
   card.tabID = reinterpret_cast<NSUInteger>(tab);
 
   return card;
 }
 
 - (void)rebuildCards {
   [stackModel_ removeAllCards];
 
-  for (Tab* tab in tabModel_) {
+  for (Tab* tab in tabModel_.get()) {
     StackCard* card = [self buildCardFromTab:tab];
     [stackModel_ addCard:card];
   }
 
   [self.observer cardSetRecreatedCards:self];
 }
 
 - (void)displayCard:(StackCard*)card {
   DCHECK(view_);
   card.view.hidden = [stackModel_ cardIsCovered:card];
@@ skipping 39 matching lines @@
 
 - (CardView*)cardViewWithFrame:(CGRect)frame forStackCard:(StackCard*)card {
   DCHECK(!ignoresTabModelChanges_);
   NSUInteger cardIndex = [self.cards indexOfObject:card];
   DCHECK(cardIndex != NSNotFound);
   Tab* tab = [tabModel_ tabAtIndex:cardIndex];
   DCHECK(tab);
   NSString* title = tab.title;
   if (![title length])
     title = tab.urlDisplayString;
-  CardView* view = [[CardView alloc] initWithFrame:frame
-                                       isIncognito:[tabModel_ isOffTheRecord]];
+  CardView* view =
+      [[[CardView alloc] initWithFrame:frame
+                           isIncognito:[tabModel_ isOffTheRecord]] autorelease];
   [view setTitle:title];
   [view setFavicon:[tab favicon]];
   [tab retrieveSnapshot:^(UIImage* image) {
     [view setImage:image];
   }];
   if (!view.image)
     [view setImage:[CRWWebController defaultSnapshotImage]];
   view.closeButtonSide = self.closeButtonSide;
 
   return view;
@@ skipping 84 matching lines @@
 @implementation CardSet (Testing)
 
 - (StackCard*)cardForTab:(Tab*)tab {
   NSUInteger tabIndex = [tabModel_ indexOfTab:tab];
   if (tabIndex == NSNotFound)
     return nil;
   return [self.cards objectAtIndex:tabIndex];
 }
 
 - (void)setStackModelForTesting:(CardStackLayoutManager*)stackModel {
-  stackModel_ = stackModel;
+  stackModel_.reset([stackModel retain]);
 }
 
 @end