Reland of [ObjC ARC] Converts ios/chrome/browser/ui/contextual_search:contextual_search to ARC.

ios/chrome/browser/ui/contextual_search/contextual_search_panel_view.mm

 // Copyright 2014 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/contextual_search/contextual_search_panel_view.h"
 
 #import "base/ios/crb_protocol_observers.h"
-#include "base/ios/weak_nsobject.h"
 #include "base/logging.h"
-#include "base/mac/scoped_block.h"
-#include "base/mac/scoped_nsobject.h"
 #import "ios/chrome/browser/procedural_block_types.h"
 #import "ios/chrome/browser/ui/contextual_search/contextual_search_panel_protocols.h"
 #import "ios/chrome/browser/ui/uikit_ui_util.h"
 #import "ios/chrome/common/material_timing.h"
 #import "ios/third_party/material_components_ios/src/components/ShadowElevations/src/MaterialShadowElevations.h"
 #import "ios/third_party/material_components_ios/src/components/ShadowLayer/src/MaterialShadowLayer.h"
 
+#if !defined(__has_feature) || !__has_feature(objc_arc)
+#error "This file requires ARC support."
+#endif
+
 namespace {
 
 // Animation timings.
 const NSTimeInterval kPanelAnimationDuration = ios::material::kDuration3;
 const NSTimeInterval kDismissAnimationDuration = ios::material::kDuration1;
 
 // Elevation (in MD vertical space) of the panel when dismissed and peeking.
 const CGFloat kShadowElevation = MDCShadowElevationMenu;
 
 }  // namespace
 
 @interface ContextualSearchPanelObservers
     : CRBProtocolObservers<ContextualSearchPanelMotionObserver>
 @end
 @implementation ContextualSearchPanelObservers
 
 @end
 
 @interface ContextualSearchPanelView ()<UIGestureRecognizerDelegate,
                                         ContextualSearchPanelMotionObserver>
 
 // A subview whose content scrolls and whose scrolling is synchronized with
 // panel dragging. This means that if the scrolling subview is being scrolled,
 // that motion will not cause the panel to move, but if the scrolling reaches
 // the end of its possible range, the gesture will then start dragging the
 // panel.
-@property(nonatomic, assign)
+@property(nonatomic, weak)
     UIView<ContextualSearchPanelScrollSynchronizer>* scrollSynchronizer;
 
 // Private readonly property to be used by weak pointers to |self| for non-
 // retaining access to the underlying ivar in blocks.
-@property(nonatomic, readonly) ContextualSearchPanelObservers* observers;
+@property(nonatomic, strong, readonly)
+    ContextualSearchPanelObservers* observers;
 
 // Utility to generate a PanelMotion struct for the panel's current position.
 - (ContextualSearch::PanelMotion)motion;
 @end
 
 @implementation ContextualSearchPanelView {
   UIStackView* _contents;
 
   // Constraints that define the size of this view. These will be cleared and
   // regenerated when the horizontal size class changes.
-  base::scoped_nsobject<NSArray> _sizingConstraints;
+  NSArray* _sizingConstraints;
 
   CGPoint _draggingStartPosition;
   CGPoint _scrolledOffset;
-  base::scoped_nsobject<UIPanGestureRecognizer> _dragRecognizer;
-
-  base::scoped_nsobject<ContextualSearchPanelObservers> _observers;
-
-  base::scoped_nsobject<PanelConfiguration> _configuration;
-
-  base::WeakNSProtocol<id<ContextualSearchPanelScrollSynchronizer>>
-      _scrollSynchronizer;
+  UIPanGestureRecognizer* _dragRecognizer;
 
   // Guide that's used to position this view.
-  base::WeakNSObject<UILayoutGuide> _positioningGuide;
+  __weak UILayoutGuide* _positioningGuide;
   // Constraint that sets the size of |_positioningView| so this view is
   // positioned correctly for its state.
-  base::WeakNSObject<NSLayoutConstraint> _positioningViewConstraint;
+  __weak NSLayoutConstraint* _positioningViewConstraint;
   // Other constraints that determine the position of this view.
-  base::scoped_nsobject<NSArray> _positioningConstraints;
+  NSArray* _positioningConstraints;
 
   // Promotion state variables.
   BOOL _resizingForPromotion;
   CGFloat _promotionVerticalOffset;
 
   // YES if dragging started inside the content view and scrolling is possible.
   BOOL _maybeScrollContent;
   // YES if the drag is happening along with scrolling the content view.
   BOOL _isScrollingContent;
 
   // YES if dragging upwards has occurred.
   BOOL _hasDraggedUp;
 }
 
 @synthesize state = _state;
+@synthesize scrollSynchronizer = _scrollSynchronizer;
+@synthesize configuration = _configuration;
+@synthesize observers = _observers;
 
 + (BOOL)requiresConstraintBasedLayout {
   return YES;
 }
 
 #pragma mark - Initializers
 
 - (instancetype)initWithConfiguration:(PanelConfiguration*)configuration {
   if ((self = [super initWithFrame:CGRectZero])) {
-    _configuration.reset([configuration retain]);
+    _configuration = configuration;
     _state = ContextualSearch::DISMISSED;
 
     self.translatesAutoresizingMaskIntoConstraints = NO;
     self.backgroundColor = [UIColor whiteColor];
     self.accessibilityIdentifier = @"contextualSearchPanel";
 
-    _observers.reset([[ContextualSearchPanelObservers
-        observersWithProtocol:@protocol(ContextualSearchPanelMotionObserver)]
-        retain]);
+    _observers = [ContextualSearchPanelObservers
+        observersWithProtocol:@protocol(ContextualSearchPanelMotionObserver)];
     [self addMotionObserver:self];
 
     // Add gesture recognizer.
-    _dragRecognizer.reset([[UIPanGestureRecognizer alloc]
+    _dragRecognizer = [[UIPanGestureRecognizer alloc]
         initWithTarget:self
-                action:@selector(handleDragFrom:)]);
+                action:@selector(handleDragFrom:)];
     [self addGestureRecognizer:_dragRecognizer];
     [_dragRecognizer setDelegate:self];
 
     // Set up the stack view that holds the panel content
-    _contents = [[[UIStackView alloc] initWithFrame:self.bounds] autorelease];
+    _contents = [[UIStackView alloc] initWithFrame:self.bounds];
     [self addSubview:_contents];
     _contents.translatesAutoresizingMaskIntoConstraints = NO;
     _contents.accessibilityIdentifier = @"panelContents";
     [NSLayoutConstraint activateConstraints:@[
       [_contents.centerXAnchor constraintEqualToAnchor:self.centerXAnchor],
       [_contents.centerYAnchor constraintEqualToAnchor:self.centerYAnchor],
       [_contents.widthAnchor constraintEqualToAnchor:self.widthAnchor],
       [_contents.heightAnchor constraintEqualToAnchor:self.heightAnchor]
     ]];
     _contents.axis = UILayoutConstraintAxisVertical;
@@ skipping 54 matching lines @@
   [[_positioningGuide owningView] removeLayoutGuide:_positioningGuide];
   [_observers panelIsPromoting:self];
   [self setNeedsUpdateConstraints];
   [self updateConstraintsIfNeeded];
   [self layoutIfNeeded];
 }
 
 #pragma mark - Public property getters/setters
 
 - (PanelConfiguration*)configuration {
-  return _configuration.get();
-}
-
-- (void)setScrollSynchronizer:
-    (id<ContextualSearchPanelScrollSynchronizer>)scrollSynchronizer {
-  _scrollSynchronizer.reset(scrollSynchronizer);
-}
-
-- (id<ContextualSearchPanelScrollSynchronizer>)scrollSynchronizer {
-  return _scrollSynchronizer;
+  return _configuration;
 }
 
 - (ContextualSearchPanelObservers*)observers {
   return _observers;
 }
 
 - (void)setState:(ContextualSearch::PanelState)state {
   if (state == _state)
     return;
 
   [_positioningViewConstraint setActive:NO];
-  _positioningViewConstraint.reset();
-  base::WeakNSObject<ContextualSearchPanelView> weakSelf(self);
+  _positioningViewConstraint = nil;
+  __weak ContextualSearchPanelView* weakSelf = self;
   void (^transform)(void) = ^{
-    base::scoped_nsobject<ContextualSearchPanelView> strongSelf(
-        [weakSelf retain]);
+    ContextualSearchPanelView* strongSelf = weakSelf;
     if (strongSelf) {
       [strongSelf setNeedsUpdateConstraints];
       [[strongSelf superview] layoutIfNeeded];
       [[strongSelf observers] panel:strongSelf
                   didMoveWithMotion:[strongSelf motion]];
     }
   };
 
-  base::mac::ScopedBlock<ProceduralBlockWithBool> completion;
+  ProceduralBlockWithBool completion;
   NSTimeInterval animationDuration;
   if (state == ContextualSearch::DISMISSED) {
     animationDuration = kDismissAnimationDuration;
-    completion.reset(
-        ^(BOOL) {
-          [weakSelf setHidden:YES];
-        },
-        base::scoped_policy::RETAIN);
+    completion = [^(BOOL) {
+      [weakSelf setHidden:YES];
+    } copy];
   } else {
     self.hidden = NO;
     animationDuration = kPanelAnimationDuration;
   }
 
   // Animations from a dismissed state are EaseOut, others are EaseInOut.
   ios::material::Curve curve = _state == ContextualSearch::DISMISSED
                                    ? ios::material::CurveEaseOut
                                    : ios::material::CurveEaseInOut;
 
@@ skipping 22 matching lines @@
         .active = YES;
     [self.topAnchor constraintEqualToAnchor:self.superview.topAnchor
                                    constant:_promotionVerticalOffset]
         .active = YES;
   } else {
     // Don't update sizing constraints if there isn't a defined horizontal size
     // yet.
     if (self.traitCollection.horizontalSizeClass !=
             UIUserInterfaceSizeClassUnspecified &&
         !_sizingConstraints) {
-      _sizingConstraints.reset(
-          [[_configuration constraintsForSizingPanel:self] retain]);
+      _sizingConstraints = [_configuration constraintsForSizingPanel:self];
       [NSLayoutConstraint activateConstraints:_sizingConstraints];
     }
     // Update positioning constraints if they don't exist.
     if (!_positioningConstraints) {
       NSArray* positioningConstraints = @[
         [[_positioningGuide topAnchor]
             constraintEqualToAnchor:self.superview.topAnchor],
         [[_positioningGuide bottomAnchor]
             constraintEqualToAnchor:self.topAnchor]
       ];
       [NSLayoutConstraint activateConstraints:positioningConstraints];
 
-      _positioningConstraints.reset([positioningConstraints retain]);
+      _positioningConstraints = positioningConstraints;
     }
     // Always update the positioning view constraint.
-    _positioningViewConstraint.reset([self.configuration
-        constraintForPositioningGuide:_positioningGuide
-                              atState:self.state]);
+    _positioningViewConstraint =
+        [self.configuration constraintForPositioningGuide:_positioningGuide
+                                                  atState:self.state];
     [_positioningViewConstraint setActive:YES];
   }
   [super updateConstraints];
 }
 
 - (void)didMoveToSuperview {
   if (!self.superview)
     return;
   // Set up the invisible positioning view used to constrain this view's
   // position.
-  UILayoutGuide* positioningGuide = [[[UILayoutGuide alloc] init] autorelease];
+  UILayoutGuide* positioningGuide = [[UILayoutGuide alloc] init];
   positioningGuide.identifier = @"contextualSearchPosition";
   [self.superview addLayoutGuide:positioningGuide];
-  _positioningGuide.reset(positioningGuide);
+  _positioningGuide = positioningGuide;
   [self setNeedsUpdateConstraints];
 }
 
 - (void)traitCollectionDidChange:(UITraitCollection*)previousTraitCollection {
   if (previousTraitCollection.horizontalSizeClass ==
       self.traitCollection.horizontalSizeClass) {
     return;
   }
 
   [self dismissPanel];
 
   [_configuration
       setHorizontalSizeClass:self.traitCollection.horizontalSizeClass];
   [NSLayoutConstraint deactivateConstraints:_sizingConstraints];
-  _sizingConstraints.reset();
+  _sizingConstraints = nil;
   [self setNeedsUpdateConstraints];
 }
 
 - (void)layoutSubviews {
   [super layoutSubviews];
   self.configuration.containerSize = self.superview.bounds.size;
   // Update the shadow path for this view.
   // Consider switching to "full" MDCShadowLayer.
   MDCShadowMetrics* metrics =
       [MDCShadowMetrics metricsWithElevation:kShadowElevation];
   UIBezierPath* shadowPath = [UIBezierPath bezierPathWithRect:self.bounds];
   self.layer.shadowPath = shadowPath.CGPath;
   self.layer.shadowOpacity = metrics.topShadowOpacity;
   self.layer.shadowRadius = metrics.topShadowRadius;
 }
 
 - (void)dismissPanel {
   ContextualSearch::PanelMotion motion;
   motion.state = ContextualSearch::DISMISSED;
   motion.nextState = ContextualSearch::DISMISSED;
   motion.gradation = 0;
   motion.position = 0;
   [_observers panel:self didStopMovingWithMotion:motion];
 }
 
 - (void)dealloc {
   [self removeMotionObserver:self];
   [self removeGestureRecognizer:_dragRecognizer];
   [[_positioningGuide owningView] removeLayoutGuide:_positioningGuide];
-  [super dealloc];
 }
 
 #pragma mark - Gesture recognizer callbacks
 
 - (void)handleDragFrom:(UIGestureRecognizer*)gestureRecognizer {
   UIPanGestureRecognizer* recognizer =
       static_cast<UIPanGestureRecognizer*>(gestureRecognizer);
   if ([recognizer state] == UIGestureRecognizerStateCancelled) {
     recognizer.enabled = YES;
     [self dismissPanel];
@@ skipping 84 matching lines @@
   }
 }
 
 #pragma mark - UIGestureRecognizerDelegate methods
 
 - (BOOL)gestureRecognizer:(UIGestureRecognizer*)gestureRecognizer
     shouldRecognizeSimultaneouslyWithGestureRecognizer:
         (UIGestureRecognizer*)otherGestureRecognizer {
   // Allow the drag recognizer and the panel content scroll recognizer to
   // co-recognize.
-  if (gestureRecognizer == _dragRecognizer.get() &&
+  if (gestureRecognizer == _dragRecognizer &&
       otherGestureRecognizer == self.scrollSynchronizer.scrollRecognizer) {
     return YES;
   }
 
-  if (gestureRecognizer == _dragRecognizer.get() &&
+  if (gestureRecognizer == _dragRecognizer &&
       [_dragRecognizer state] == UIGestureRecognizerStateChanged) {
     [gestureRecognizer setEnabled:NO];
   }
   return NO;
 }
 
 @end