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

ios/chrome/browser/ui/side_swipe/side_swipe_controller.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/side_swipe/side_swipe_controller.h"
 
 #include <memory>
 
-#import "base/ios/weak_nsobject.h"
 #include "components/reading_list/core/reading_list_model.h"
 #import "ios/chrome/browser/browser_state/chrome_browser_state.h"
 #import "ios/chrome/browser/infobars/infobar_container_view.h"
 #import "ios/chrome/browser/reading_list/reading_list_model_factory.h"
 #import "ios/chrome/browser/snapshots/snapshot_cache.h"
 #import "ios/chrome/browser/tabs/tab.h"
 #import "ios/chrome/browser/tabs/tab_model_observer.h"
 #import "ios/chrome/browser/ui/reading_list/reading_list_side_swipe_provider.h"
 #import "ios/chrome/browser/ui/side_swipe/card_side_swipe_view.h"
 #import "ios/chrome/browser/ui/side_swipe/history_side_swipe_provider.h"
 #import "ios/chrome/browser/ui/side_swipe/side_swipe_navigation_view.h"
 #import "ios/chrome/browser/ui/side_swipe/side_swipe_util.h"
 #import "ios/chrome/browser/ui/side_swipe_gesture_recognizer.h"
 #include "ios/chrome/browser/ui/ui_util.h"
 #import "ios/web/public/web_state/web_state_observer_bridge.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 ios_internal {
 NSString* const kSideSwipeWillStartNotification =
     @"kSideSwipeWillStartNotification";
 NSString* const kSideSwipeDidStopNotification =
     @"kSideSwipeDidStopNotification";
 }  // namespace ios_internal
 
 namespace {
 
 enum class SwipeType { NONE, CHANGE_TAB, CHANGE_PAGE };
 
 // Swipe starting distance from edge.
 const CGFloat kSwipeEdge = 20;
 
 // Distance between sections of iPad side swipe.
 const CGFloat kIpadTabSwipeDistance = 100;
 
 // Number of tabs to keep in the grey image cache.
 const NSUInteger kIpadGreySwipeTabCount = 8;
 }
 
 @interface SideSwipeController ()<CRWWebStateObserver,
                                   TabModelObserver,
                                   UIGestureRecognizerDelegate> {
  @private
 
-  base::WeakNSObject<TabModel> model_;
+  __weak TabModel* model_;
 
   // Side swipe view for tab navigation.
-  base::scoped_nsobject<CardSideSwipeView> tabSideSwipeView_;
+  CardSideSwipeView* tabSideSwipeView_;
 
   // Side swipe view for page navigation.
-  base::scoped_nsobject<SideSwipeNavigationView> pageSideSwipeView_;
+  SideSwipeNavigationView* pageSideSwipeView_;
 
   // YES if the user is currently swiping.
   BOOL inSwipe_;
 
   // Swipe gesture recognizer.
-  base::scoped_nsobject<SideSwipeGestureRecognizer> swipeGestureRecognizer_;
+  SideSwipeGestureRecognizer* swipeGestureRecognizer_;
 
-  base::scoped_nsobject<SideSwipeGestureRecognizer> panGestureRecognizer_;
+  SideSwipeGestureRecognizer* panGestureRecognizer_;
 
   // Used in iPad side swipe gesture, tracks the starting tab index.
   NSUInteger startingTabIndex_;
 
   // If the swipe is for a page change or a tab change.
   SwipeType swipeType_;
 
   // Bridge to observe the web state from Objective-C.
   std::unique_ptr<web::WebStateObserverBridge> webStateObserverBridge_;
 
   // Curtain over web view while waiting for it to load.
-  base::scoped_nsobject<UIView> curtain_;
+  UIView* curtain_;
 
   // Provides forward/back action for history entries.
-  base::scoped_nsobject<HistorySideSwipeProvider> historySideSwipeProvider_;
+  HistorySideSwipeProvider* historySideSwipeProvider_;
 
   // Provides forward action for reading list.
-  base::scoped_nsobject<ReadingListSideSwipeProvider>
-      readingListSideSwipeProvider_;
+  ReadingListSideSwipeProvider* readingListSideSwipeProvider_;
 
-  base::WeakNSProtocol<id<SideSwipeContentProvider>> currentContentProvider_;
+  __weak id<SideSwipeContentProvider> currentContentProvider_;
 }
 
 // Load grey snapshots for the next |kIpadGreySwipeTabCount| tabs in
 // |direction|.
 - (void)createGreyCache:(UISwipeGestureRecognizerDirection)direction;
 // Tell snapshot cache to clear grey cache.
 - (void)deleteGreyCache;
 // Handle tab side swipe for iPad.  Change tabs according to swipe distance.
 - (void)handleiPadTabSwipe:(SideSwipeGestureRecognizer*)gesture;
 // Handle tab side swipe for iPhone. Introduces a CardSideSwipeView to convey
@@ skipping 11 matching lines @@
 
 @synthesize inSwipe = inSwipe_;
 @synthesize swipeDelegate = swipeDelegate_;
 @synthesize snapshotDelegate = snapshotDelegate_;
 
 - (id)initWithTabModel:(TabModel*)model
           browserState:(ios::ChromeBrowserState*)browserState {
   DCHECK(model);
   self = [super init];
   if (self) {
-    model_.reset(model);
+    model_ = model;
     [model_ addObserver:self];
-    historySideSwipeProvider_.reset(
-        [[HistorySideSwipeProvider alloc] initWithTabModel:model_]);
+    historySideSwipeProvider_ =
+        [[HistorySideSwipeProvider alloc] initWithTabModel:model_];
 
-    readingListSideSwipeProvider_.reset([[ReadingListSideSwipeProvider alloc]
+    readingListSideSwipeProvider_ = [[ReadingListSideSwipeProvider alloc]
         initWithReadingList:ReadingListModelFactory::GetForBrowserState(
-                                browserState)]);
+                                browserState)];
   }
   return self;
 }
 
 - (void)dealloc {
   [model_ removeObserver:self];
-  [super dealloc];
 }
 
 - (void)addHorizontalGesturesToView:(UIView*)view {
-  swipeGestureRecognizer_.reset([[SideSwipeGestureRecognizer alloc]
+  swipeGestureRecognizer_ = [[SideSwipeGestureRecognizer alloc]
       initWithTarget:self
-              action:@selector(handleSwipe:)]);
+              action:@selector(handleSwipe:)];
   [swipeGestureRecognizer_ setMaximumNumberOfTouches:1];
   [swipeGestureRecognizer_ setDelegate:self];
   [swipeGestureRecognizer_ setSwipeEdge:kSwipeEdge];
   [view addGestureRecognizer:swipeGestureRecognizer_];
 
   // Add a second gesture recognizer to handle swiping on the toolbar to change
   // tabs.
-  panGestureRecognizer_.reset([[SideSwipeGestureRecognizer alloc]
-      initWithTarget:self
-              action:@selector(handlePan:)]);
+  panGestureRecognizer_ =
+      [[SideSwipeGestureRecognizer alloc] initWithTarget:self
+                                                  action:@selector(handlePan:)];
   [panGestureRecognizer_ setMaximumNumberOfTouches:1];
   [panGestureRecognizer_ setSwipeThreshold:48];
   [panGestureRecognizer_ setDelegate:self];
   [view addGestureRecognizer:panGestureRecognizer_];
 }
 
 - (NSSet*)swipeRecognizers {
-  return [NSSet setWithObjects:swipeGestureRecognizer_.get(), nil];
+  return [NSSet setWithObjects:swipeGestureRecognizer_, nil];
 }
 
 - (void)setEnabled:(BOOL)enabled {
   [swipeGestureRecognizer_ setEnabled:enabled];
 }
 
 - (BOOL)shouldAutorotate {
   return !([tabSideSwipeView_ window] || inSwipe_);
 }
 
@@ skipping 76 matching lines @@
     if (index == (NSInteger)startingTabIndex_)
       break;
 
     Tab* tab = [model_ tabAtIndex:index];
     if (tab && tab.webController.usePlaceholderOverlay) {
       [sessionIDs addObject:tab.tabId];
     }
     index = index + dx;
   }
   [[SnapshotCache sharedInstance] createGreyCache:sessionIDs];
-  for (Tab* tab in model_.get()) {
+  for (Tab* tab in model_) {
     tab.useGreyImageCache = YES;
   }
 }
 
 - (void)deleteGreyCache {
   [[SnapshotCache sharedInstance] removeGreyCache];
-  for (Tab* tab in model_.get()) {
+  for (Tab* tab in model_) {
     tab.useGreyImageCache = NO;
   }
 }
 
 - (void)handlePan:(SideSwipeGestureRecognizer*)gesture {
   if (!IsIPadIdiom()) {
     return [self handleiPhoneTabSwipe:gesture];
   } else {
     return [self handleiPadTabSwipe:gesture];
   }
@@ skipping 105 matching lines @@
 // Show swipe to navigate.
 - (void)handleSwipeToNavigate:(SideSwipeGestureRecognizer*)gesture {
   if (gesture.state == UIGestureRecognizerStateBegan) {
     // If the toolbar is hidden, move it to visible.
     [[model_ currentTab] updateFullscreenWithToolbarVisible:YES];
 
     inSwipe_ = YES;
     [swipeDelegate_ updateAccessoryViewsForSideSwipeWithVisibility:NO];
     BOOL goBack = IsSwipingBack(gesture.direction);
 
-    currentContentProvider_.reset([self contentProviderForGesture:goBack]);
+    currentContentProvider_ = [self contentProviderForGesture:goBack];
     BOOL canNavigate = currentContentProvider_ != nil;
 
     CGRect gestureBounds = gesture.view.bounds;
     CGFloat headerHeight = [swipeDelegate_ headerHeight];
     CGRect navigationFrame =
         CGRectMake(CGRectGetMinX(gestureBounds),
                    CGRectGetMinY(gestureBounds) + headerHeight,
                    CGRectGetWidth(gestureBounds),
                    CGRectGetHeight(gestureBounds) - headerHeight);
 
-    pageSideSwipeView_.reset([[SideSwipeNavigationView alloc]
+    pageSideSwipeView_ = [[SideSwipeNavigationView alloc]
         initWithFrame:navigationFrame
         withDirection:gesture.direction
           canNavigate:canNavigate
                 image:[currentContentProvider_ paneIcon]
-        rotateForward:[currentContentProvider_ rotateForwardIcon]]);
+        rotateForward:[currentContentProvider_ rotateForwardIcon]];
     [pageSideSwipeView_ setTargetView:[swipeDelegate_ contentView]];
 
     [gesture.view insertSubview:pageSideSwipeView_
                    belowSubview:[[swipeDelegate_ toolbarController] view]];
   }
 
-  base::WeakNSObject<Tab> weakCurrentTab([model_ currentTab]);
+  __weak Tab* weakCurrentTab = [model_ currentTab];
   [pageSideSwipeView_ handleHorizontalPan:gesture
       onOverThresholdCompletion:^{
         BOOL wantsBack = IsSwipingBack(gesture.direction);
         web::WebState* webState = [weakCurrentTab webState];
         if (wantsBack) {
           [currentContentProvider_ goBack:webState];
         } else {
           [currentContentProvider_ goForward:webState];
         }
 
@@ skipping 25 matching lines @@
     CGRect frame = [[swipeDelegate_ contentView] frame];
 
     // Add horizontal stack view controller.
     CGFloat headerHeight =
         [self.snapshotDelegate snapshotContentAreaForTab:[model_ currentTab]]
             .origin.y;
     if (tabSideSwipeView_) {
       [tabSideSwipeView_ setFrame:frame];
       [tabSideSwipeView_ setTopMargin:headerHeight];
     } else {
-      tabSideSwipeView_.reset([[CardSideSwipeView alloc]
-          initWithFrame:frame
-              topMargin:headerHeight
-                  model:model_]);
+      tabSideSwipeView_ = [[CardSideSwipeView alloc] initWithFrame:frame
+                                                         topMargin:headerHeight
+                                                             model:model_];
       [tabSideSwipeView_ setAutoresizingMask:UIViewAutoresizingFlexibleWidth |
                                              UIViewAutoresizingFlexibleHeight];
       [tabSideSwipeView_ setDelegate:swipeDelegate_];
       [tabSideSwipeView_ setBackgroundColor:[UIColor blackColor]];
     }
 
     // Ensure that there's an up-to-date snapshot of the current tab.
     [[model_ currentTab] updateSnapshotWithOverlay:YES visibleFrameOnly:YES];
     // Hide the infobar after snapshot has been updated (see the previous line)
     // to avoid it obscuring the cards in the side swipe view.
@@ skipping 12 matching lines @@
 
     // Remove content area so it doesn't receive any pan events.
     [[swipeDelegate_ contentView] removeFromSuperview];
   }
 
   [tabSideSwipeView_ handleHorizontalPan:gesture];
 }
 
 - (void)addCurtainWithCompletionHandler:(ProceduralBlock)completionHandler {
   if (!curtain_) {
-    curtain_.reset(
-        [[UIView alloc] initWithFrame:[swipeDelegate_ contentView].bounds]);
+    curtain_ =
+        [[UIView alloc] initWithFrame:[swipeDelegate_ contentView].bounds];
     [curtain_ setBackgroundColor:[UIColor whiteColor]];
   }
   [[swipeDelegate_ contentView] addSubview:curtain_];
 
   // Fallback in case load takes a while. 3 seconds is a balance between how
   // long it can take a web view to clear the previous page image, and what
   // feels like to 'too long' to see the curtain.
   [self performSelector:@selector(dismissCurtainWithCompletionHandler:)
-             withObject:[[completionHandler copy] autorelease]
+             withObject:[completionHandler copy]
              afterDelay:3];
 }
 
 - (void)resetContentView {
   CGRect frame = [swipeDelegate_ contentView].frame;
   frame.origin.x = 0;
   [swipeDelegate_ contentView].frame = frame;
 }
 
 - (void)dismissCurtainWithCompletionHandler:(ProceduralBlock)completionHandler {
   [NSObject cancelPreviousPerformRequestsWithTarget:self];
   webStateObserverBridge_.reset();
   [curtain_ removeFromSuperview];
-  curtain_.reset();
+  curtain_ = nil;
   completionHandler();
 }
 
 #pragma mark - CRWWebStateObserver Methods
 
 - (void)webStateDidStopLoading:(web::WebState*)webState {
   [self dismissCurtainWithCompletionHandler:^{
     inSwipe_ = NO;
   }];
 }
 
 #pragma mark - TabModelObserver Methods
 
 - (void)tabModel:(TabModel*)model
     didChangeActiveTab:(Tab*)newTab
            previousTab:(Tab*)previousTab
                atIndex:(NSUInteger)index {
   // Toggling the gesture's enabled state off and on will effectively cancel
   // the gesture recognizer.
   [swipeGestureRecognizer_ setEnabled:NO];
   [swipeGestureRecognizer_ setEnabled:YES];
 }
 
 @end