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

ios/chrome/browser/ui/stack_view/card_stack_layout_manager_unittest.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.
 
-#include "base/mac/scoped_nsobject.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/stack_card.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/platform_test.h"
 
+#if !defined(__has_feature) || !__has_feature(objc_arc)
+#error "This file requires ARC support."
+#endif
+
 @interface CardStackLayoutManager (Private)
 - (CGFloat)minStackStaggerAmount;
 - (CGFloat)scrollCardAwayFromNeighborAmount;
 - (CGFloat)staggerOffsetForIndexFromEdge:(NSInteger)countFromEdge;
 - (CGFloat)maximumCardSeparation;
 @end
 
 // A mock version of StackCard.
 @interface MockStackCard : NSObject
 
@@ skipping 84 matching lines @@
   }
 }
 
 // Creates a new |CardStackLayoutManager|, adds |n| cards to it, and sets
 // dimensional/positioning parameters to the constants defined above.
 CardStackLayoutManager* newStackOfNCards(unsigned int n, BOOL layoutIsVertical)
     NS_RETURNS_RETAINED {
   CardStackLayoutManager* stack = [[CardStackLayoutManager alloc] init];
   stack.layoutIsVertical = layoutIsVertical;
   for (unsigned int i = 0; i < n; ++i) {
-    base::scoped_nsobject<StackCard> card(
-        (StackCard*)[[MockStackCard alloc] init]);
+    StackCard* card = (StackCard*)[[MockStackCard alloc] init];

[sdefresne, 2017/02/09 13:47:49]

nit: please change this to use a static_cast:

  StackCard* card = static_cast<StackCard*>([[MockStackCard alloc] init]);

[lody, 2017/02/09 16:00:03]

Done.

     [stack addCard:card];
   }
 
   CGSize cardSize = CGSizeMake(kCardWidth, kCardHeight);
   [stack setCardSize:cardSize];
   [stack setStartLimit:kMargin];
   [stack setMaxStagger:kMaxStagger];
   [stack setLayoutAxisPosition:kAxisPosition];
   CGFloat cardLength = layoutIsVertical ? cardSize.height : cardSize.width;
   [stack setMaximumOverextensionAmount:cardLength / 2.0];
 
   return stack;
 }
 
 TEST_F(CardStackLayoutManagerTest, CardSizing) {
   BOOL boolValues[2] = {NO, YES};
   for (unsigned long i = 0; i < arraysize(boolValues); i++) {
-    base::scoped_nsobject<CardStackLayoutManager> stack(
-        [[CardStackLayoutManager alloc] init]);
-    stack.get().layoutIsVertical = boolValues[i];
+    CardStackLayoutManager* stack = [[CardStackLayoutManager alloc] init];
+    stack.layoutIsVertical = boolValues[i];
 
-    base::scoped_nsobject<StackCard> view1(
-        (StackCard*)[[MockStackCard alloc] init]);
-    base::scoped_nsobject<StackCard> view2(
-        (StackCard*)[[MockStackCard alloc] init]);
-    base::scoped_nsobject<StackCard> view3(
-        (StackCard*)[[MockStackCard alloc] init]);
-    [stack addCard:view1.get()];
-    [stack addCard:view2.get()];
-    [stack addCard:view3.get()];
+    StackCard* view1 = (StackCard*)[[MockStackCard alloc] init];

[sdefresne, 2017/02/09 13:47:49]

ditto x 3

[lody, 2017/02/09 16:00:03]

Done.

+    StackCard* view2 = (StackCard*)[[MockStackCard alloc] init];
+    StackCard* view3 = (StackCard*)[[MockStackCard alloc] init];
+    [stack addCard:view1];
+    [stack addCard:view2];
+    [stack addCard:view3];
     // Ensure that removed cards are not altered.
     [stack removeCard:view2];
 
     CGSize cardSize = CGSizeMake(111, 222);
     [stack setCardSize:cardSize];
 
     EXPECT_FLOAT_EQ(cardSize.width, [view1 size].width);
     EXPECT_FLOAT_EQ(cardSize.height, [view1 size].height);
     EXPECT_FLOAT_EQ(0.0, [view2 size].width);
     EXPECT_FLOAT_EQ(0.0, [view2 size].height);
     EXPECT_FLOAT_EQ(cardSize.width, [view3 size].width);
     EXPECT_FLOAT_EQ(cardSize.height, [view3 size].height);
 
     // But it should be automatically updated when it's added again.
     [stack addCard:view2];
     EXPECT_FLOAT_EQ(cardSize.width, [view2 size].width);
     EXPECT_FLOAT_EQ(cardSize.height, [view2 size].height);
   }
 }
 
 TEST_F(CardStackLayoutManagerTest, StackSizes) {
   BOOL boolValues[2] = {NO, YES};
   for (unsigned long i = 0; i < arraysize(boolValues); i++) {
-    base::scoped_nsobject<CardStackLayoutManager> stack(
-        [[CardStackLayoutManager alloc] init]);
-    stack.get().layoutIsVertical = boolValues[i];
+    CardStackLayoutManager* stack = [[CardStackLayoutManager alloc] init];
+    stack.layoutIsVertical = boolValues[i];
     CGRect cardFrame = CGRectMake(0, 0, 100, 200);
     [stack setCardSize:cardFrame.size];
     [stack setMaxStagger:30];
 
     // Asking the size for a collapsed stack should give the same result.
     CGFloat emptyCollapsedSize = [stack fullyCollapsedStackLength];
     for (int i = 0; i < 10; ++i) {
-      base::scoped_nsobject<StackCard> card(
-          (StackCard*)[[UIView alloc] initWithFrame:cardFrame]);
+      StackCard* card = (StackCard*)[[UIView alloc] initWithFrame:cardFrame];

[sdefresne, 2017/02/09 13:47:49]

ditto

[lody, 2017/02/09 16:00:03]

Done.

       [stack addCard:card];
     }
     CGFloat largeCollapsedSize = [stack fullyCollapsedStackLength];
     EXPECT_FLOAT_EQ(emptyCollapsedSize, largeCollapsedSize);
 
     // But a fanned-out stack should get bigger, and the maximum stack size
     // should be larger still.
     CGFloat largeExpandedSize = [stack fannedStackLength];
     EXPECT_GT(largeExpandedSize, largeCollapsedSize);
     CGFloat largeMaximumSize = [stack maximumStackLength];
     EXPECT_GT(largeMaximumSize, largeExpandedSize);
-    base::scoped_nsobject<StackCard> card(
-        (StackCard*)[[MockStackCard alloc] init]);
+    StackCard* card = (StackCard*)[[MockStackCard alloc] init];

[sdefresne, 2017/02/09 13:47:49]

ditto

[lody, 2017/02/09 16:00:03]

Done.

     [stack addCard:card];
     CGFloat evenLargerExpandedSize = [stack fannedStackLength];
     EXPECT_LT(largeExpandedSize, evenLargerExpandedSize);
     CGFloat evenLargerMaximumSize = [stack maximumStackLength];
     EXPECT_LT(largeMaximumSize, evenLargerMaximumSize);
 
     // And start limit shouldn't matter.
     [stack setStartLimit:10];
     EXPECT_FLOAT_EQ(emptyCollapsedSize, [stack fullyCollapsedStackLength]);
     EXPECT_FLOAT_EQ(evenLargerExpandedSize, [stack fannedStackLength]);
     EXPECT_FLOAT_EQ(evenLargerMaximumSize, [stack maximumStackLength]);
   }
 }
 
 TEST_F(CardStackLayoutManagerTest, StackLayout) {
   BOOL boolValues[2] = {NO, YES};
   for (unsigned long i = 0; i < arraysize(boolValues); i++) {
     const unsigned int kCardCount = 30;
-    base::scoped_nsobject<CardStackLayoutManager> stack(
-        newStackOfNCards(kCardCount, boolValues[i]));
+    CardStackLayoutManager* stack = newStackOfNCards(kCardCount, boolValues[i]);
 
     const float kEndLimit =
         kDefaultEndLimitFraction * [stack fannedStackLength];
     [stack setEndLimit:kEndLimit];
     [stack fanOutCardsWithStartIndex:0];
 
     EXPECT_EQ(kCardCount, [[stack cards] count]);
     ValidateCardPositioningConstraints(stack, kEndLimit, true);
     EXPECT_EQ(0, [stack lastStartStackCardIndex]);
     EXPECT_LT(0, [stack firstEndStackCardIndex]);
     for (NSInteger i = 0; i < [stack firstEndStackCardIndex]; i++) {
       StackCard* card = [[stack cards] objectAtIndex:i];
       EXPECT_FLOAT_EQ(kMargin + i * kMaxStagger,
                       LayoutOffset(stack, card.layout.position));
     }
   }
 }
 
 TEST_F(CardStackLayoutManagerTest, PreservingPositionsOnCardSizeChange) {
   BOOL boolValues[2] = {NO, YES};
   for (unsigned long i = 0; i < arraysize(boolValues); i++) {
     const unsigned int kCardCount = 3;
-    base::scoped_nsobject<CardStackLayoutManager> stack(
-        newStackOfNCards(kCardCount, boolValues[i]));
+    CardStackLayoutManager* stack = newStackOfNCards(kCardCount, boolValues[i]);
 
     const float kEndLimit =
         kDefaultEndLimitFraction * [stack fannedStackLength];
     [stack setEndLimit:kEndLimit];
     [stack fanOutCardsWithStartIndex:0];
 
     EXPECT_EQ(kCardCount, [[stack cards] count]);
     ValidateCardPositioningConstraints(stack, kEndLimit, true);
     EXPECT_EQ(0, [stack lastStartStackCardIndex]);
     EXPECT_LT(0, [stack firstEndStackCardIndex]);
@@ skipping 15 matching lines @@
       EXPECT_FLOAT_EQ(kMargin + i * kMaxStagger,
                       LayoutOffset(stack, card.layout.position));
     }
   }
 }
 
 TEST_F(CardStackLayoutManagerTest, SwappingPositionsOnOrientationChange) {
   BOOL boolValues[2] = {NO, YES};
   for (unsigned long i = 0; i < arraysize(boolValues); i++) {
     const unsigned int kCardCount = 3;
-    base::scoped_nsobject<CardStackLayoutManager> stack(
-        newStackOfNCards(kCardCount, boolValues[i]));
+    CardStackLayoutManager* stack = newStackOfNCards(kCardCount, boolValues[i]);
 
     const float kEndLimit =
         kDefaultEndLimitFraction * [stack fannedStackLength];
     [stack setEndLimit:kEndLimit];
     [stack fanOutCardsWithStartIndex:0];
 
     EXPECT_EQ(kCardCount, [[stack cards] count]);
     ValidateCardPositioningConstraints(stack, kEndLimit, true);
     EXPECT_EQ(0, [stack lastStartStackCardIndex]);
     EXPECT_LT(0, [stack firstEndStackCardIndex]);
@@ skipping 14 matching lines @@
       StackCard* card = [[stack cards] objectAtIndex:i];
       EXPECT_FLOAT_EQ(kMargin + i * kMaxStagger,
                       LayoutOffset(stack, card.layout.position));
     }
   }
 }
 TEST_F(CardStackLayoutManagerTest, EndStackRecomputationOnEndLimitChange) {
   BOOL boolValues[2] = {NO, YES};
   for (unsigned long i = 0; i < arraysize(boolValues); i++) {
     const unsigned int kCardCount = 3;
-    base::scoped_nsobject<CardStackLayoutManager> stack(
-        newStackOfNCards(kCardCount, boolValues[i]));
+    CardStackLayoutManager* stack = newStackOfNCards(kCardCount, boolValues[i]);
 
     CGFloat endLimit = [stack maximumStackLength];
     [stack setEndLimit:endLimit];
     [stack fanOutCardsWithStartIndex:0];
 
     EXPECT_EQ(kCardCount, [[stack cards] count]);
     ValidateCardPositioningConstraints(stack, endLimit, true);
     EXPECT_EQ(0, [stack lastStartStackCardIndex]);
     EXPECT_EQ((int)kCardCount, [stack firstEndStackCardIndex]);
     for (NSInteger i = 0; i < [stack firstEndStackCardIndex]; i++) {
@@ skipping 25 matching lines @@
       EXPECT_FLOAT_EQ(kMargin + i * kMaxStagger,
                       LayoutOffset(stack, card.layout.position));
     }
   }
 }
 
 TEST_F(CardStackLayoutManagerTest, StackLayoutAtSpecificIndex) {
   BOOL boolValues[2] = {NO, YES};
   for (unsigned long i = 0; i < arraysize(boolValues); i++) {
     const unsigned int kCardCount = 30;
-    base::scoped_nsobject<CardStackLayoutManager> stack(
-        newStackOfNCards(kCardCount, boolValues[i]));
+    CardStackLayoutManager* stack = newStackOfNCards(kCardCount, boolValues[i]);
 
     NSInteger startIndex = 10;
 
     const float kEndLimit =
         kDefaultEndLimitFraction * [stack fannedStackLength];
     [stack setEndLimit:kEndLimit];
     [stack fanOutCardsWithStartIndex:startIndex];
 
     EXPECT_EQ(kCardCount, [[stack cards] count]);
     ValidateCardPositioningConstraints(stack, kEndLimit, true);
     EXPECT_EQ(startIndex, [stack lastStartStackCardIndex]);
     // Take into account start stack when verifying position of card at
     // |startIndex|.
     StackCard* startCard = [[stack cards] objectAtIndex:startIndex];
     EXPECT_FLOAT_EQ(kMargin + [stack staggerOffsetForIndexFromEdge:startIndex],
                     LayoutOffset(stack, startCard.layout.position));
     NSInteger firstEndStackCardIndex = [stack firstEndStackCardIndex];
     for (NSInteger i = startIndex + 1; i < firstEndStackCardIndex; i++) {
       StackCard* card = [[stack cards] objectAtIndex:i];
       EXPECT_FLOAT_EQ(kMargin + (i - startIndex) * kMaxStagger,
                       LayoutOffset(stack, card.layout.position));
     }
   }
 }
 
 TEST_F(CardStackLayoutManagerTest, CardIsCovered) {
   BOOL boolValues[2] = {NO, YES};
   for (unsigned long i = 0; i < arraysize(boolValues); i++) {
     const unsigned int kCardCount = 3;
-    base::scoped_nsobject<CardStackLayoutManager> stack(
-        newStackOfNCards(kCardCount, boolValues[i]));
+    CardStackLayoutManager* stack = newStackOfNCards(kCardCount, boolValues[i]);
 
     const float kEndLimit =
         kDefaultEndLimitFraction * [stack fannedStackLength];
     [stack setEndLimit:kEndLimit];
     [stack fanOutCardsWithStartIndex:0];
 
     ValidateCardPositioningConstraints(stack, kEndLimit, true);
     EXPECT_EQ(0, [stack lastStartStackCardIndex]);
     EXPECT_EQ((int)kCardCount, [stack firstEndStackCardIndex]);
     // Since no cards are hidden in the start or end stack, all cards should
     // be visible (i.e., not covered).
     for (NSUInteger i = 0; i < kCardCount; i++) {
       StackCard* card = [[stack cards] objectAtIndex:i];
       EXPECT_FALSE([stack cardIsCovered:card]);
     }
     // Moving the second card to the same location as the third card should
     // result in the third card covering the second card.
     StackCard* secondCard = [[stack cards] objectAtIndex:1];
     StackCard* thirdCard = [[stack cards] objectAtIndex:2];
     secondCard.layout = thirdCard.layout;
     EXPECT_TRUE([stack cardIsCovered:secondCard]);
     EXPECT_FALSE([stack cardIsCovered:thirdCard]);
   }
 }
 
 TEST_F(CardStackLayoutManagerTest, CardIsCollapsed) {
   BOOL boolValues[2] = {NO, YES};
   for (unsigned long i = 0; i < arraysize(boolValues); i++) {
     const unsigned int kCardCount = 3;
-    base::scoped_nsobject<CardStackLayoutManager> stack(
-        newStackOfNCards(kCardCount, boolValues[i]));
+    CardStackLayoutManager* stack = newStackOfNCards(kCardCount, boolValues[i]);
 
     const float kEndLimit =
         kDefaultEndLimitFraction * [stack fannedStackLength];
     [stack setEndLimit:kEndLimit];
     [stack fanOutCardsWithStartIndex:0];
 
     ValidateCardPositioningConstraints(stack, kEndLimit, true);
     EXPECT_EQ(0, [stack lastStartStackCardIndex]);
     EXPECT_EQ((int)kCardCount, [stack firstEndStackCardIndex]);
     // Since the cards are fully fanned out, no cards should be collapsed.
@@ skipping 12 matching lines @@
       collapsedLayout.position.leading -= [stack minStackStaggerAmount];
     secondCard.layout = collapsedLayout;
     EXPECT_TRUE([stack cardIsCollapsed:secondCard]);
   }
 }
 
 TEST_F(CardStackLayoutManagerTest, BasicScroll) {
   BOOL boolValues[2] = {NO, YES};
   for (unsigned long i = 0; i < arraysize(boolValues); i++) {
     const unsigned int kCardCount = 3;
-    base::scoped_nsobject<CardStackLayoutManager> stack(
-        newStackOfNCards(kCardCount, boolValues[i]));
+    CardStackLayoutManager* stack = newStackOfNCards(kCardCount, boolValues[i]);
     StackCard* firstCard = [[stack cards] objectAtIndex:0];
 
     const float kEndLimit =
         kDefaultEndLimitFraction * [stack fannedStackLength];
     [stack setEndLimit:kEndLimit];
     [stack fanOutCardsWithStartIndex:0];
     ValidateCardPositioningConstraints(stack, kEndLimit, true);
     EXPECT_FLOAT_EQ(kMargin, LayoutOffset(stack, firstCard.layout.position));
     EXPECT_FLOAT_EQ(kMaxStagger, SeparationOnLayoutAxis(stack, 0, 1));
     EXPECT_FLOAT_EQ(kMaxStagger, SeparationOnLayoutAxis(stack, 1, 2));
@@ skipping 18 matching lines @@
     EXPECT_FLOAT_EQ(kMargin, LayoutOffset(stack, firstCard.layout.position));
     EXPECT_FLOAT_EQ(kMaxStagger, SeparationOnLayoutAxis(stack, 0, 1));
     EXPECT_FLOAT_EQ(kMaxStagger, SeparationOnLayoutAxis(stack, 1, 2));
   }
 }
 
 TEST_F(CardStackLayoutManagerTest, ScrollCardAwayFromNeighbor) {
   BOOL boolValues[2] = {NO, YES};
   for (unsigned long i = 0; i < arraysize(boolValues); i++) {
     const unsigned int kCardCount = 3;
-    base::scoped_nsobject<CardStackLayoutManager> stack(
-        newStackOfNCards(kCardCount, boolValues[i]));
+    CardStackLayoutManager* stack = newStackOfNCards(kCardCount, boolValues[i]);
     StackCard* firstCard = [[stack cards] objectAtIndex:0];
 
     // Configure the stack so that the first card is > the scroll-away distance
     // from the end stack, but the second card is not.
     const float kEndLimit =
         [stack scrollCardAwayFromNeighborAmount] + 2 * [stack maxStagger];
     [stack setEndLimit:kEndLimit];
     [stack fanOutCardsWithStartIndex:0];
     ValidateCardPositioningConstraints(stack, kEndLimit, true);
     EXPECT_FLOAT_EQ(kMargin, LayoutOffset(stack, firstCard.layout.position));
@@ skipping 45 matching lines @@
     EXPECT_FLOAT_EQ(separation,
                     kEndLimit - LayoutOffset(stack, thirdCard.layout.position));
     EXPECT_EQ(3, [stack firstEndStackCardIndex]);
   }
 }
 
 TEST_F(CardStackLayoutManagerTest, ScrollNotScrollingLeadingCards) {
   BOOL boolValues[2] = {NO, YES};
   for (unsigned long i = 0; i < arraysize(boolValues); i++) {
     const unsigned int kCardCount = 4;
-    base::scoped_nsobject<CardStackLayoutManager> stack(
-        newStackOfNCards(kCardCount, boolValues[i]));
+    CardStackLayoutManager* stack = newStackOfNCards(kCardCount, boolValues[i]);
     StackCard* firstCard = [[stack cards] objectAtIndex:0];
 
     // Make the stack large enough to fan out all its cards to avoid having to
     // worry about the end stack below.
     const float kEndLimit = [stack fannedStackLength];
     [stack setEndLimit:kEndLimit];
     [stack fanOutCardsWithStartIndex:0];
     ValidateCardPositioningConstraints(stack, kEndLimit, true);
     EXPECT_FLOAT_EQ(kMargin, LayoutOffset(stack, firstCard.layout.position));
     EXPECT_FLOAT_EQ(kMaxStagger, SeparationOnLayoutAxis(stack, 0, 1));
@@ skipping 30 matching lines @@
     EXPECT_FLOAT_EQ(kMaxStagger, SeparationOnLayoutAxis(stack, 0, 1));
     EXPECT_FLOAT_EQ(kMaxStagger, SeparationOnLayoutAxis(stack, 1, 2));
     EXPECT_FLOAT_EQ(kMaxStagger - 10, SeparationOnLayoutAxis(stack, 2, 3));
   }
 }
 
 TEST_F(CardStackLayoutManagerTest, ScrollCollapseExpansionOfLargeStack) {
   BOOL boolValues[2] = {NO, YES};
   for (unsigned long i = 0; i < arraysize(boolValues); i++) {
     const unsigned int kCardCount = 10;
-    base::scoped_nsobject<CardStackLayoutManager> stack(
-        newStackOfNCards(kCardCount, boolValues[i]));
+    CardStackLayoutManager* stack = newStackOfNCards(kCardCount, boolValues[i]);
 
     const float kEndLimit =
         kDefaultEndLimitFraction * [stack fannedStackLength];
     [stack setEndLimit:kEndLimit];
 
     [stack fanOutCardsWithStartIndex:0];
     ValidateCardPositioningConstraints(stack, kEndLimit, true);
     EXPECT_TRUE([stack stackIsFullyFannedOut]);
     EXPECT_FALSE([stack stackIsFullyCollapsed]);
     EXPECT_FALSE([stack stackIsFullyOverextended]);
@@ skipping 30 matching lines @@
     EXPECT_FALSE([stack stackIsFullyFannedOut]);
     EXPECT_TRUE([stack stackIsFullyCollapsed]);
     EXPECT_TRUE([stack stackIsFullyOverextended]);
   }
 }
 
 TEST_F(CardStackLayoutManagerTest, ScrollCollapseExpansionOfStackCornerCases) {
   BOOL boolValues[2] = {NO, YES};
   const unsigned int kCardCount = 1;
   for (unsigned long i = 0; i < arraysize(boolValues); i++) {
-    base::scoped_nsobject<CardStackLayoutManager> stack(
-        newStackOfNCards(kCardCount, boolValues[i]));
+    CardStackLayoutManager* stack = newStackOfNCards(kCardCount, boolValues[i]);
 
     // A laid-out stack with one card is fully collapsed and fully fanned out,
     // but not fully overextended.
     [stack fanOutCardsWithStartIndex:0];
     EXPECT_TRUE([stack stackIsFullyFannedOut]);
     EXPECT_TRUE([stack stackIsFullyCollapsed]);
     EXPECT_FALSE([stack stackIsFullyOverextended]);
 
     // A stack with no cards is fully collapsed, fully fanned out, and fully
     // overextended.
     [stack removeCard:[[stack cards] objectAtIndex:0]];
     EXPECT_TRUE([stack stackIsFullyFannedOut]);
     EXPECT_TRUE([stack stackIsFullyCollapsed]);
     EXPECT_TRUE([stack stackIsFullyOverextended]);
   }
 }
 
 TEST_F(CardStackLayoutManagerTest, OneCardOverscroll) {
   BOOL boolValues[2] = {NO, YES};
   for (unsigned long i = 0; i < arraysize(boolValues); i++) {
     const unsigned int kCardCount = 1;
     const float kScrollAwayAmount = 20.0;
-    base::scoped_nsobject<CardStackLayoutManager> stack(
-        newStackOfNCards(kCardCount, boolValues[i]));
+    CardStackLayoutManager* stack = newStackOfNCards(kCardCount, boolValues[i]);
     StackCard* firstCard = [[stack cards] objectAtIndex:0];
 
     const float kEndLimit =
         kDefaultEndLimitFraction * [stack fannedStackLength];
     [stack setEndLimit:kEndLimit];
     [stack fanOutCardsWithStartIndex:0];
     ValidateCardPositioningConstraints(stack, kEndLimit, true);
     EXPECT_FLOAT_EQ(kMargin, LayoutOffset(stack, firstCard.layout.position));
 
     // Scrolling toward end should result in overscroll.
@@ skipping 26 matching lines @@
     EXPECT_FLOAT_EQ(kMargin - kScrollAwayAmount,
                     LayoutOffset(stack, firstCard.layout.position));
   }
 }
 
 TEST_F(CardStackLayoutManagerTest, MaximumOverextensionAmount) {
   BOOL boolValues[2] = {NO, YES};
   for (unsigned long i = 0; i < arraysize(boolValues); i++) {
     const unsigned int kCardCount = 1;
     const float kScrollAwayAmount = 20.0;
-    base::scoped_nsobject<CardStackLayoutManager> stack(
-        newStackOfNCards(kCardCount, boolValues[i]));
+    CardStackLayoutManager* stack = newStackOfNCards(kCardCount, boolValues[i]);
     StackCard* firstCard = [[stack cards] objectAtIndex:0];
 
     const float kEndLimit =
         kDefaultEndLimitFraction * [stack fannedStackLength];
     [stack setEndLimit:kEndLimit];
     [stack fanOutCardsWithStartIndex:0];
     ValidateCardPositioningConstraints(stack, kEndLimit, true);
     EXPECT_FLOAT_EQ(kMargin, LayoutOffset(stack, firstCard.layout.position));
 
     // Scrolling toward start/end should have no impact.
@@ skipping 51 matching lines @@
                     LayoutOffset(stack, firstCard.layout.position));
     EXPECT_FLOAT_EQ(maxOverextensionAmount, [stack overextensionAmount]);
   }
 }
 
 TEST_F(CardStackLayoutManagerTest, DecayOnOverscroll) {
   BOOL boolValues[2] = {NO, YES};
   for (unsigned long i = 0; i < arraysize(boolValues); i++) {
     const unsigned int kCardCount = 1;
     const float kScrollAwayAmount = 10.0;
-    base::scoped_nsobject<CardStackLayoutManager> stack(
-        newStackOfNCards(kCardCount, boolValues[i]));
+    CardStackLayoutManager* stack = newStackOfNCards(kCardCount, boolValues[i]);
     StackCard* firstCard = [[stack cards] objectAtIndex:0];
 
     const float kEndLimit =
         kDefaultEndLimitFraction * [stack fannedStackLength];
     [stack setEndLimit:kEndLimit];
     [stack fanOutCardsWithStartIndex:0];
     ValidateCardPositioningConstraints(stack, kEndLimit, true);
     EXPECT_FLOAT_EQ(kMargin, LayoutOffset(stack, firstCard.layout.position));
 
     // Scrolling toward end by |kScrollAwayAmount| should result in overscroll.
@@ skipping 34 matching lines @@
     EXPECT_GT(kMargin + 3 * kScrollAwayAmount,
               LayoutOffset(stack, firstCard.layout.position));
   }
 }
 
 TEST_F(CardStackLayoutManagerTest, EliminateOverextension) {
   BOOL boolValues[2] = {NO, YES};
   for (unsigned long i = 0; i < arraysize(boolValues); i++) {
     const unsigned int kCardCount = 2;
     const float kScrollAwayAmount = 20.0;
-    base::scoped_nsobject<CardStackLayoutManager> stack(
-        newStackOfNCards(kCardCount, boolValues[i]));
+    CardStackLayoutManager* stack = newStackOfNCards(kCardCount, boolValues[i]);
     StackCard* firstCard = [[stack cards] objectAtIndex:0];
     StackCard* secondCard = [[stack cards] objectAtIndex:1];
 
     const float kEndLimit =
         kDefaultEndLimitFraction * [stack fannedStackLength];
     [stack setEndLimit:kEndLimit];
     [stack fanOutCardsWithStartIndex:0];
     ValidateCardPositioningConstraints(stack, kEndLimit, true);
     EXPECT_FLOAT_EQ(kMargin, LayoutOffset(stack, firstCard.layout.position));
 
@@ skipping 71 matching lines @@
     EXPECT_FLOAT_EQ(secondCardInitialOrigin + kScrollAwayAmount,
                     LayoutOffset(stack, secondCard.layout.position));
   }
 }
 
 TEST_F(CardStackLayoutManagerTest, MultiCardOverscroll) {
   BOOL boolValues[2] = {NO, YES};
   for (unsigned long i = 0; i < arraysize(boolValues); i++) {
     const unsigned int kCardCount = 3;
     const float kScrollAwayAmount = 100.0;
-    base::scoped_nsobject<CardStackLayoutManager> stack(
-        newStackOfNCards(kCardCount, boolValues[i]));
+    CardStackLayoutManager* stack = newStackOfNCards(kCardCount, boolValues[i]);
     StackCard* firstCard = [[stack cards] objectAtIndex:0];
 
     const float kEndLimit =
         kDefaultEndLimitFraction * [stack fannedStackLength];
     [stack setEndLimit:kEndLimit];
     [stack fanOutCardsWithStartIndex:0];
     ValidateCardPositioningConstraints(stack, kEndLimit, true);
     EXPECT_FLOAT_EQ(kMargin, LayoutOffset(stack, firstCard.layout.position));
     EXPECT_FLOAT_EQ(kMaxStagger, SeparationOnLayoutAxis(stack, 0, 1));
     EXPECT_FLOAT_EQ(kMaxStagger, SeparationOnLayoutAxis(stack, 1, 2));
@@ skipping 35 matching lines @@
     EXPECT_TRUE([stack overextensionTowardStartOnCardAtIndex:0]);
     EXPECT_FLOAT_EQ(kMargin - 10,
                     LayoutOffset(stack, firstCard.layout.position));
   }
 }
 
 TEST_F(CardStackLayoutManagerTest, Fling) {
   BOOL boolValues[2] = {NO, YES};
   for (unsigned long i = 0; i < arraysize(boolValues); i++) {
     const unsigned int kCardCount = 3;
-    base::scoped_nsobject<CardStackLayoutManager> stack(
-        newStackOfNCards(kCardCount, boolValues[i]));
+    CardStackLayoutManager* stack = newStackOfNCards(kCardCount, boolValues[i]);
     StackCard* firstCard = [[stack cards] objectAtIndex:0];
 
     const float kEndLimit =
         kDefaultEndLimitFraction * [stack fannedStackLength];
     [stack setEndLimit:kEndLimit];
     [stack fanOutCardsWithStartIndex:0];
     ValidateCardPositioningConstraints(stack, kEndLimit, true);
     EXPECT_FLOAT_EQ(kMargin, LayoutOffset(stack, firstCard.layout.position));
     EXPECT_FLOAT_EQ(kMaxStagger, SeparationOnLayoutAxis(stack, 0, 1));
     EXPECT_FLOAT_EQ(kMaxStagger, SeparationOnLayoutAxis(stack, 1, 2));
@@ skipping 16 matching lines @@
     ValidateCardPositioningConstraints(stack, kEndLimit, true);
     EXPECT_TRUE([stack overextensionTowardStartOnCardAtIndex:0]);
     EXPECT_FALSE([stack overextensionTowardEndOnFirstCard]);
   }
 }
 
 TEST_F(CardStackLayoutManagerTest, ScrollAroundStartStack) {
   BOOL boolValues[2] = {NO, YES};
   for (unsigned long i = 0; i < arraysize(boolValues); i++) {
     const unsigned int kCardCount = 3;
-    base::scoped_nsobject<CardStackLayoutManager> stack(
-        newStackOfNCards(kCardCount, boolValues[i]));
+    CardStackLayoutManager* stack = newStackOfNCards(kCardCount, boolValues[i]);
 
     const float kEndLimit =
         kDefaultEndLimitFraction * [stack fannedStackLength];
     [stack setEndLimit:kEndLimit];
     [stack fanOutCardsWithStartIndex:0];
 
     EXPECT_FLOAT_EQ(kMaxStagger, SeparationOnLayoutAxis(stack, 0, 1));
     EXPECT_EQ(0, [stack lastStartStackCardIndex]);
     ValidateCardPositioningConstraints(stack, kEndLimit, true);
 
@@ skipping 41 matching lines @@
     ValidateCardPositioningConstraints(stack, kEndLimit, true);
     EXPECT_EQ(0, [stack lastStartStackCardIndex]);
     EXPECT_FLOAT_EQ(kMaxStagger, SeparationOnLayoutAxis(stack, 1, 2));
   }
 }
 
 TEST_F(CardStackLayoutManagerTest, ScrollAroundEndStack) {
   BOOL boolValues[2] = {NO, YES};
   for (unsigned long i = 0; i < arraysize(boolValues); i++) {
     const unsigned int kCardCount = 7;
-    base::scoped_nsobject<CardStackLayoutManager> stack(
-        newStackOfNCards(kCardCount, boolValues[i]));
+    CardStackLayoutManager* stack = newStackOfNCards(kCardCount, boolValues[i]);
 
     const float kEndLimit = 0.2 * [stack fannedStackLength];
     [stack setEndLimit:kEndLimit];
     [stack fanOutCardsWithStartIndex:4];
 
     EXPECT_FLOAT_EQ(kMaxStagger, SeparationOnLayoutAxis(stack, 5, 6));
     EXPECT_EQ(4, [stack lastStartStackCardIndex]);
     EXPECT_EQ(7, [stack firstEndStackCardIndex]);
     ValidateCardPositioningConstraints(stack, kEndLimit, true);
 
@@ skipping 42 matching lines @@
     ValidateCardPositioningConstraints(stack, kEndLimit, true);
     EXPECT_EQ([stack firstEndStackCardIndex], 7);
     EXPECT_FLOAT_EQ(kMaxStagger, SeparationOnLayoutAxis(stack, 5, 6));
   }
 }
 
 TEST_F(CardStackLayoutManagerTest, BasicMultitouch) {
   BOOL boolValues[2] = {NO, YES};
   for (unsigned long i = 0; i < arraysize(boolValues); i++) {
     const unsigned int kCardCount = 3;
-    base::scoped_nsobject<CardStackLayoutManager> stack(
-        newStackOfNCards(kCardCount, boolValues[i]));
+    CardStackLayoutManager* stack = newStackOfNCards(kCardCount, boolValues[i]);
 
     const float kEndLimit =
         kDefaultEndLimitFraction * [stack fannedStackLength];
     [stack setEndLimit:kEndLimit];
     [stack fanOutCardsWithStartIndex:0];
 
     ValidateCardPositioningConstraints(stack, kEndLimit, true);
     EXPECT_FLOAT_EQ(kMaxStagger, SeparationOnLayoutAxis(stack, 0, 1));
     EXPECT_FLOAT_EQ(kMaxStagger, SeparationOnLayoutAxis(stack, 1, 2));
 
     [stack handleMultitouchWithFirstDelta:-10
                               secondDelta:50
                            firstCardIndex:1
                           secondCardIndex:2
                          decayOnOverpinch:YES];
     ValidateCardPositioningConstraints(stack, kEndLimit, false);
     EXPECT_FLOAT_EQ(kMaxStagger - 10, SeparationOnLayoutAxis(stack, 0, 1));
     EXPECT_FLOAT_EQ(kMaxStagger + 60, SeparationOnLayoutAxis(stack, 1, 2));
   }
 }
 
 TEST_F(CardStackLayoutManagerTest, MultitouchBoundedByNeighbor) {
   BOOL boolValues[2] = {NO, YES};
   for (unsigned long i = 0; i < arraysize(boolValues); i++) {
     const unsigned int kCardCount = 3;
-    base::scoped_nsobject<CardStackLayoutManager> stack(
-        newStackOfNCards(kCardCount, boolValues[i]));
+    CardStackLayoutManager* stack = newStackOfNCards(kCardCount, boolValues[i]);
 
     // Make sure that the stack end limit isn't hit in this test.
     const float kEndLimit = 2.0 * [stack maximumStackLength];
     [stack setEndLimit:kEndLimit];
     [stack fanOutCardsWithStartIndex:0];
 
     ValidateCardPositioningConstraints(stack, kEndLimit, true);
     EXPECT_FLOAT_EQ(kMaxStagger, SeparationOnLayoutAxis(stack, 0, 1));
     EXPECT_FLOAT_EQ(kMaxStagger, SeparationOnLayoutAxis(stack, 1, 2));
 
@@ skipping 22 matching lines @@
                           secondCardIndex:2
                          decayOnOverpinch:YES];
     ValidateCardPositioningConstraints(stack, kEndLimit, false);
   }
 }
 
 TEST_F(CardStackLayoutManagerTest, OverpinchTowardStart) {
   BOOL boolValues[2] = {NO, YES};
   for (unsigned long i = 0; i < arraysize(boolValues); i++) {
     const unsigned int kCardCount = 2;
-    base::scoped_nsobject<CardStackLayoutManager> stack(
-        newStackOfNCards(kCardCount, boolValues[i]));
+    CardStackLayoutManager* stack = newStackOfNCards(kCardCount, boolValues[i]);
 
     const float kEndLimit =
         kDefaultEndLimitFraction * [stack fannedStackLength];
     [stack setEndLimit:kEndLimit];
     [stack fanOutCardsWithStartIndex:0];
 
     ValidateCardPositioningConstraints(stack, kEndLimit, true);
     StackCard* firstCard = [[stack cards] objectAtIndex:0];
     LayoutRectPosition firstCardPosition = firstCard.layout.position;
     StackCard* secondCard = [[stack cards] objectAtIndex:1];
@@ skipping 12 matching lines @@
                     LayoutOffset(stack, firstCard.layout.position));
     EXPECT_FLOAT_EQ(LayoutOffset(stack, secondCardPosition) + 10,
                     LayoutOffset(stack, secondCard.layout.position));
   }
 }
 
 TEST_F(CardStackLayoutManagerTest, OverpinchTowardEnd) {
   BOOL boolValues[2] = {NO, YES};
   for (unsigned long i = 0; i < arraysize(boolValues); i++) {
     const unsigned int kCardCount = 2;
-    base::scoped_nsobject<CardStackLayoutManager> stack(
-        newStackOfNCards(kCardCount, boolValues[i]));
+    CardStackLayoutManager* stack = newStackOfNCards(kCardCount, boolValues[i]);
 
     const float kEndLimit =
         kDefaultEndLimitFraction * [stack fannedStackLength];
     [stack setEndLimit:kEndLimit];
     [stack fanOutCardsWithStartIndex:0];
 
     ValidateCardPositioningConstraints(stack, kEndLimit, true);
     StackCard* firstCard = [[stack cards] objectAtIndex:0];
     LayoutRectPosition firstCardPosition = firstCard.layout.position;
     StackCard* secondCard = [[stack cards] objectAtIndex:1];
@@ skipping 10 matching lines @@
                     LayoutOffset(stack, firstCard.layout.position));
     EXPECT_FLOAT_EQ(LayoutOffset(stack, secondCardPosition) + 10,
                     LayoutOffset(stack, secondCard.layout.position));
   }
 }
 
 TEST_F(CardStackLayoutManagerTest, StressMultitouch) {
   BOOL boolValues[2] = {NO, YES};
   for (unsigned long i = 0; i < arraysize(boolValues); i++) {
     const unsigned int kCardCount = 30;
-    base::scoped_nsobject<CardStackLayoutManager> stack(
-        newStackOfNCards(kCardCount, boolValues[i]));
+    CardStackLayoutManager* stack = newStackOfNCards(kCardCount, boolValues[i]);
 
     const float kEndLimit =
         kDefaultEndLimitFraction * [stack fannedStackLength];
     [stack setEndLimit:kEndLimit];
     [stack fanOutCardsWithStartIndex:0];
 
     ValidateCardPositioningConstraints(stack, kEndLimit, true);
 
     [stack handleMultitouchWithFirstDelta:-10
                               secondDelta:50
@@ skipping 15 matching lines @@
                           secondCardIndex:4
                          decayOnOverpinch:YES];
     ValidateCardPositioningConstraints(stack, kEndLimit, false);
   }
 }
 
 TEST_F(CardStackLayoutManagerTest, ScrollAfterMultitouch) {
   BOOL boolValues[2] = {NO, YES};
   for (unsigned long i = 0; i < arraysize(boolValues); i++) {
     const unsigned int kCardCount = 3;
-    base::scoped_nsobject<CardStackLayoutManager> stack(
-        newStackOfNCards(kCardCount, boolValues[i]));
+    CardStackLayoutManager* stack = newStackOfNCards(kCardCount, boolValues[i]);
 
     const float kEndLimit =
         kDefaultEndLimitFraction * [stack fannedStackLength];
     const float kPinchDistance = 50;
     [stack setEndLimit:kEndLimit];
     [stack fanOutCardsWithStartIndex:0];
 
     ValidateCardPositioningConstraints(stack, kEndLimit, true);
     EXPECT_FLOAT_EQ(kMaxStagger, SeparationOnLayoutAxis(stack, 1, 2));
 
@@ skipping 24 matching lines @@
     // Separation between cards should be maintained.
     EXPECT_FLOAT_EQ(kMaxStagger + kPinchDistance,
                     SeparationOnLayoutAxis(stack, 1, 2));
   }
 }
 
 TEST_F(CardStackLayoutManagerTest, ScrollEveningOutAfterMultitouch) {
   BOOL boolValues[2] = {NO, YES};
   for (unsigned long i = 0; i < arraysize(boolValues); i++) {
     const unsigned int kCardCount = 3;
-    base::scoped_nsobject<CardStackLayoutManager> stack(
-        newStackOfNCards(kCardCount, boolValues[i]));
+    CardStackLayoutManager* stack = newStackOfNCards(kCardCount, boolValues[i]);
 
     const float kEndLimit =
         kDefaultEndLimitFraction * [stack fannedStackLength];
     const float kPinchDistance = kMaxStagger / 2.0;
     [stack setEndLimit:kEndLimit];
     [stack fanOutCardsWithStartIndex:0];
 
     ValidateCardPositioningConstraints(stack, kEndLimit, true);
     EXPECT_FLOAT_EQ(kMaxStagger, SeparationOnLayoutAxis(stack, 1, 2));
 
@@ skipping 38 matching lines @@
           scrollLeadingCards:YES];
     ValidateCardPositioningConstraints(stack, kEndLimit, false);
     EXPECT_FLOAT_EQ(kMaxStagger, SeparationOnLayoutAxis(stack, 1, 2));
   }
 }
 
 TEST_F(CardStackLayoutManagerTest, ScrollAroundStartStackAfterMultitouch) {
   BOOL boolValues[2] = {NO, YES};
   for (unsigned long i = 0; i < arraysize(boolValues); i++) {
     const unsigned int kCardCount = 3;
-    base::scoped_nsobject<CardStackLayoutManager> stack(
-        newStackOfNCards(kCardCount, boolValues[i]));
+    CardStackLayoutManager* stack = newStackOfNCards(kCardCount, boolValues[i]);
 
     const float kEndLimit =
         kDefaultEndLimitFraction * [stack fannedStackLength];
     const float kPinchDistance = 50;
     [stack setEndLimit:kEndLimit];
     [stack fanOutCardsWithStartIndex:0];
 
     EXPECT_FLOAT_EQ(kMaxStagger, SeparationOnLayoutAxis(stack, 0, 1));
     ValidateCardPositioningConstraints(stack, kEndLimit, true);
 
@@ skipping 37 matching lines @@
            decayOnOverscroll:YES
           scrollLeadingCards:YES];
     EXPECT_FLOAT_EQ(kMaxStagger, SeparationOnLayoutAxis(stack, 1, 2));
   }
 }
 
 TEST_F(CardStackLayoutManagerTest, ScrollAroundEndStackAfterMultitouch) {
   BOOL boolValues[2] = {NO, YES};
   for (unsigned long i = 0; i < arraysize(boolValues); i++) {
     const unsigned int kCardCount = 7;
-    base::scoped_nsobject<CardStackLayoutManager> stack(
-        newStackOfNCards(kCardCount, boolValues[i]));
+    CardStackLayoutManager* stack = newStackOfNCards(kCardCount, boolValues[i]);
 
     const float kEndLimit = 0.3 * [stack fannedStackLength];
     const float kPinchDistance = 20;
     [stack setEndLimit:kEndLimit];
     // Start in the middle of the stack to be able to scroll cards into the end
     // stack.
     [stack fanOutCardsWithStartIndex:4];
 
     EXPECT_FLOAT_EQ(kMaxStagger, SeparationOnLayoutAxis(stack, 5, 6));
     ValidateCardPositioningConstraints(stack, kEndLimit, true);
@@ skipping 39 matching lines @@
            decayOnOverscroll:YES
           scrollLeadingCards:YES];
     EXPECT_FLOAT_EQ(SeparationOnLayoutAxis(stack, 5, 6), kMaxStagger);
   }
 }
 
 TEST_F(CardStackLayoutManagerTest, ScrollAfterPinchOutOfStartStack) {
   BOOL boolValues[2] = {NO, YES};
   for (unsigned long i = 0; i < arraysize(boolValues); i++) {
     const unsigned int kCardCount = 3;
-    base::scoped_nsobject<CardStackLayoutManager> stack(
-        newStackOfNCards(kCardCount, boolValues[i]));
+    CardStackLayoutManager* stack = newStackOfNCards(kCardCount, boolValues[i]);
 
     const float kEndLimit =
         kDefaultEndLimitFraction * [stack fannedStackLength];
     const float kPinchDistance = 50;
     [stack setEndLimit:kEndLimit];
     [stack fanOutCardsWithStartIndex:0];
 
     EXPECT_FLOAT_EQ(kMaxStagger, SeparationOnLayoutAxis(stack, 0, 1));
     ValidateCardPositioningConstraints(stack, kEndLimit, true);
 
@@ skipping 48 matching lines @@
     ValidateCardPositioningConstraints(stack, kEndLimit, false);
     EXPECT_FLOAT_EQ(inStackSeparation + kMaxStagger,
                     SeparationOnLayoutAxis(stack, 1, 2));
   }
 }
 
 TEST_F(CardStackLayoutManagerTest, ScrollAfterPinchOutOfEndStack) {
   BOOL boolValues[2] = {NO, YES};
   for (unsigned long i = 0; i < arraysize(boolValues); i++) {
     const unsigned int kCardCount = 7;
-    base::scoped_nsobject<CardStackLayoutManager> stack(
-        newStackOfNCards(kCardCount, boolValues[i]));
+    CardStackLayoutManager* stack = newStackOfNCards(kCardCount, boolValues[i]);
 
     const float kEndLimit = 0.3 * [stack fannedStackLength];
     const float kPinchDistance = 20;
     [stack setEndLimit:kEndLimit];
     // Start in the middle of the stack to be able to scroll cards into the end
     // stack.
     [stack fanOutCardsWithStartIndex:4];
 
     EXPECT_FLOAT_EQ(kMaxStagger, SeparationOnLayoutAxis(stack, 5, 6));
     ValidateCardPositioningConstraints(stack, kEndLimit, true);
@@ skipping 53 matching lines @@
            decayOnOverscroll:YES
           scrollLeadingCards:YES];
     ValidateCardPositioningConstraints(stack, kEndLimit, false);
     EXPECT_EQ(7, [stack firstEndStackCardIndex]);
     EXPECT_FLOAT_EQ(inStackSeparation + 2 * kMaxStagger,
                     SeparationOnLayoutAxis(stack, 5, 6));
   }
 }
 
 }  // namespace