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

ios/chrome/browser/ui/bookmarks/bookmark_collection_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/bookmarks/bookmark_collection_view.h"
 
 #import <UIKit/UIGestureRecognizerSubclass.h>
 #include <algorithm>
 #include <map>
 #include <memory>
 
+#include "base/ios/weak_nsobject.h"
 #include "base/mac/bind_objc_block.h"
 #include "base/mac/foundation_util.h"
+#include "base/mac/objc_property_releaser.h"
+#include "base/mac/scoped_nsobject.h"
 #include "base/strings/sys_string_conversions.h"
 #include "components/bookmarks/browser/bookmark_model.h"
 #include "components/bookmarks/browser/bookmark_model_observer.h"
 #include "components/favicon/core/fallback_url_util.h"
 #include "components/favicon/core/large_icon_service.h"
 #include "components/favicon_base/fallback_icon_style.h"
 #include "components/favicon_base/favicon_types.h"
 #include "ios/chrome/browser/bookmarks/bookmark_model_factory.h"
 #include "ios/chrome/browser/bookmarks/bookmarks_utils.h"
 #include "ios/chrome/browser/favicon/ios_chrome_large_icon_service_factory.h"
 #import "ios/chrome/browser/ui/bookmarks/bookmark_collection_cells.h"
 #import "ios/chrome/browser/ui/bookmarks/bookmark_collection_view_background.h"
 #import "ios/chrome/browser/ui/bookmarks/bookmark_promo_cell.h"
 #import "ios/chrome/browser/ui/bookmarks/bookmark_utils_ios.h"
 #include "ios/chrome/browser/ui/ui_util.h"
 #import "ios/chrome/browser/ui/uikit_ui_util.h"
 #include "ios/chrome/grit/ios_strings.h"
 #include "skia/ext/skia_utils_ios.h"
 #include "ui/base/l10n/l10n_util_mac.h"
 
-#if !defined(__has_feature) || !__has_feature(objc_arc)
-#error "This file requires ARC support."
-#endif
-
 using bookmarks::BookmarkNode;
 
 namespace {
 
 // Used to store a pair of NSIntegers when storing a NSIndexPath in C++
 // collections.
 using IntegerPair = std::pair<NSInteger, NSInteger>;
 
 // The margin between the side of the view and the first and last tile.
 CGFloat rowMarginTablet = 24.0;
 CGFloat rowHeight = 48.0;
 // Minimal acceptable favicon size, in points.
 CGFloat minFaviconSizePt = 16;
 
 // Delay in seconds to which the empty background view will be shown when the
 // collection view is empty.
 // This delay should not be too small to let enough time to load bookmarks
 // from network.
 const NSTimeInterval kShowEmptyBookmarksBackgroundRefreshDelay = 1.0;
 
 }  // namespace
 
 @interface BookmarkCollectionView ()<UICollectionViewDataSource,
                                      UICollectionViewDelegateFlowLayout,
                                      UIGestureRecognizerDelegate> {
   std::unique_ptr<bookmarks::BookmarkModelBridge> _modelBridge;
   ios::ChromeBrowserState* _browserState;
 
+  base::mac::ObjCPropertyReleaser _propertyReleaser_BookmarkCollectionView;
+
   // Map of favicon load tasks for each index path. Used to keep track of
   // pending favicon load operations so that they can be cancelled upon cell
   // reuse. Keys are (section, item) pairs of cell index paths.
   std::map<IntegerPair, base::CancelableTaskTracker::TaskId> _faviconLoadTasks;
   // Task tracker used for async favicon loads.
   base::CancelableTaskTracker _faviconTaskTracker;
 }
 
 // Redefined to be readwrite.
 @property(nonatomic, assign) bookmarks::BookmarkModel* bookmarkModel;
 // Redefined to be readwrite.
-@property(nonatomic, strong) UICollectionView* collectionView;
+@property(nonatomic, retain) UICollectionView* collectionView;
 // Redefined to be readwrite.
 @property(nonatomic, assign) BOOL editing;
 // Detects a long press on a cell.
-@property(nonatomic, strong) UILongPressGestureRecognizer* longPressRecognizer;
+@property(nonatomic, retain) UILongPressGestureRecognizer* longPressRecognizer;
 // Background view of the collection view shown when there is no items.
-@property(nonatomic, strong)
+@property(nonatomic, retain)
     BookmarkCollectionViewBackground* emptyCollectionBackgroundView;
 // Shadow to display over the content.
-@property(nonatomic, strong) UIView* shadow;
+@property(nonatomic, retain) UIView* shadow;
 
 // Updates the editing state for the cell.
 - (void)updateEditingStateOfCell:(BookmarkCell*)cell
                      atIndexPath:(NSIndexPath*)indexPath
            animateMenuVisibility:(BOOL)animateMenuVisibility
             animateSelectedState:(BOOL)animateSelectedState;
 
 // Callback received when the user taps the menu button on the cell.
 - (void)didTapMenuButton:(BookmarkItemCell*)cell view:(UIView*)view;
 
@@ skipping 32 matching lines @@
 
 - (id)initWithFrame:(CGRect)frame {
   NOTREACHED();
   return nil;
 }
 
 - (instancetype)initWithBrowserState:(ios::ChromeBrowserState*)browserState
                                frame:(CGRect)frame {
   self = [super initWithFrame:frame];
   if (self) {
+    _propertyReleaser_BookmarkCollectionView.Init(
+        self, [BookmarkCollectionView class]);
+
     _browserState = browserState;
 
     // Set up connection to the BookmarkModel.
     _bookmarkModel =
         ios::BookmarkModelFactory::GetForBrowserState(browserState);
 
     // Set up observers.
     _modelBridge.reset(
         new bookmarks::BookmarkModelBridge(self, _bookmarkModel));
 
@@ skipping 10 matching lines @@
     // A collection view with a layout that uses a dynamic animator (aka
     // something that changes the layout over time) will crash if it is
     // deallocated while the animation is currently playing.
     // Apparently if a tick has been dispatched it will execute, invoking a
     // method on the deallocated collection.
     // The only purpose of this block is to retain the collection view for a
     // while, giving the layout a chance to perform its last tick.
     [moi self];
   });
   _faviconTaskTracker.TryCancelAll();
+  [super dealloc];
 }
 
 - (void)setupViews {
   self.backgroundColor = bookmark_utils_ios::mainBackgroundColor();
-  UICollectionViewFlowLayout* layout =
-      [[UICollectionViewFlowLayout alloc] init];
+  base::scoped_nsobject<UICollectionViewFlowLayout> layout(
+      [[UICollectionViewFlowLayout alloc] init]);
 
-  UICollectionView* collectionView =
+  base::scoped_nsobject<UICollectionView> collectionView(
       [[UICollectionView alloc] initWithFrame:self.bounds
-                         collectionViewLayout:layout];
+                         collectionViewLayout:layout]);
   self.collectionView = collectionView;
   self.collectionView.backgroundColor = [UIColor clearColor];
   self.collectionView.autoresizingMask =
       UIViewAutoresizingFlexibleHeight | UIViewAutoresizingFlexibleWidth;
   self.collectionView.alwaysBounceVertical = YES;
   self.collectionView.delegate = self;
   self.collectionView.dataSource = self;
   [self.collectionView registerClass:[BookmarkFolderCell class]
           forCellWithReuseIdentifier:[BookmarkFolderCell reuseIdentifier]];
   [self.collectionView registerClass:[BookmarkItemCell class]
           forCellWithReuseIdentifier:[BookmarkItemCell reuseIdentifier]];
   [self.collectionView registerClass:[BookmarkHeaderView class]
           forSupplementaryViewOfKind:UICollectionElementKindSectionHeader
                  withReuseIdentifier:[BookmarkHeaderView reuseIdentifier]];
   [self.collectionView
                    registerClass:[BookmarkHeaderSeparatorView class]
       forSupplementaryViewOfKind:UICollectionElementKindSectionHeader
              withReuseIdentifier:[BookmarkHeaderSeparatorView reuseIdentifier]];
   [self.collectionView registerClass:[BookmarkPromoCell class]
           forCellWithReuseIdentifier:[BookmarkPromoCell reuseIdentifier]];
 
   [self addSubview:self.collectionView];
 
   // Set up the background view shown when the collection is empty.
-  BookmarkCollectionViewBackground* emptyCollectionBackgroundView =
-      [[BookmarkCollectionViewBackground alloc] initWithFrame:CGRectZero];
+  base::scoped_nsobject<BookmarkCollectionViewBackground>
+      emptyCollectionBackgroundView(
+          [[BookmarkCollectionViewBackground alloc] initWithFrame:CGRectZero]);
   self.emptyCollectionBackgroundView = emptyCollectionBackgroundView;
   self.emptyCollectionBackgroundView.autoresizingMask =
       UIViewAutoresizingFlexibleHeight | UIViewAutoresizingFlexibleWidth;
   self.emptyCollectionBackgroundView.alpha = 0;
   self.emptyCollectionBackgroundView.text = [self textWhenCollectionIsEmpty];
 
   self.emptyCollectionBackgroundView.frame = self.collectionView.bounds;
   self.collectionView.backgroundView = self.emptyCollectionBackgroundView;
 
   [self updateShadow];
 
-  self.longPressRecognizer = [[UILongPressGestureRecognizer alloc]
-      initWithTarget:self
-              action:@selector(longPress:)];
+  self.longPressRecognizer =
+      base::scoped_nsobject<UILongPressGestureRecognizer>(
+          [[UILongPressGestureRecognizer alloc]
+              initWithTarget:self
+                      action:@selector(longPress:)]);
   self.longPressRecognizer.delegate = self;
   [self.collectionView addGestureRecognizer:self.longPressRecognizer];
 }
 
 - (void)traitCollectionDidChange:(UITraitCollection*)previousTraitCollection {
   [self updateShadow];
 }
 
 - (void)updateShadow {
   // Remove the current one, if any.
   [self.shadow removeFromSuperview];
 
   if (IsCompact(self)) {
     self.shadow =
         bookmark_utils_ios::dropShadowWithWidth(CGRectGetWidth(self.bounds));
   } else {
-    self.shadow = [[UIView alloc]
+    self.shadow = [[[UIView alloc]
         initWithFrame:CGRectMake(0, 0, CGRectGetWidth(self.bounds),
-                                 1 / [[UIScreen mainScreen] scale])];
+                                 1 / [[UIScreen mainScreen] scale])]
+        autorelease];
     self.shadow.backgroundColor = [UIColor colorWithWhite:0.0 alpha:.12];
   }
 
   [self updateShadowFrame];
   self.shadow.autoresizingMask = UIViewAutoresizingFlexibleWidth;
   if (self.editing)
     self.shadow.alpha = 0.0;
 
   // Add the new shadow.
   [self addSubview:self.shadow];
@@ skipping 222 matching lines @@
 - (void)cancelLoadingFaviconAtIndexPath:(NSIndexPath*)indexPath {
   _faviconTaskTracker.TryCancel(
       _faviconLoadTasks[IntegerPair(indexPath.section, indexPath.item)]);
 }
 
 - (void)loadFaviconAtIndexPath:(NSIndexPath*)indexPath {
   // Cancel previous load attempts.
   [self cancelLoadingFaviconAtIndexPath:indexPath];
 
   // Start loading a favicon.
-  __weak BookmarkCollectionView* weakSelf = self;
+  base::WeakNSObject<BookmarkCollectionView> weakSelf(self);
   const bookmarks::BookmarkNode* node = [self nodeAtIndexPath:indexPath];
   GURL blockURL(node->url());
   void (^faviconBlock)(const favicon_base::LargeIconResult&) = ^(
       const favicon_base::LargeIconResult& result) {
-    BookmarkCollectionView* strongSelf = weakSelf;
+    base::scoped_nsobject<BookmarkCollectionView> strongSelf([weakSelf retain]);
     if (!strongSelf)
       return;
     UIImage* favIcon = nil;
     UIColor* backgroundColor = nil;
     UIColor* textColor = nil;
     NSString* fallbackText = nil;
     if (result.bitmap.is_valid()) {
-      scoped_refptr<base::RefCountedMemory> data = result.bitmap.bitmap_data;
+      scoped_refptr<base::RefCountedMemory> data =
+          result.bitmap.bitmap_data.get();
       favIcon = [UIImage imageWithData:[NSData dataWithBytes:data->front()
                                                       length:data->size()]];
     } else if (result.fallback_icon_style) {
       backgroundColor = skia::UIColorFromSkColor(
           result.fallback_icon_style->background_color);
       textColor =
           skia::UIColorFromSkColor(result.fallback_icon_style->text_color);
 
       fallbackText =
           base::SysUTF16ToNSString(favicon::GetFallbackIconText(blockURL));
     }
 
     [strongSelf updateCellAtIndexPath:indexPath
                             withImage:favIcon
                       backgroundColor:backgroundColor
                             textColor:textColor
                          fallbackText:fallbackText];
   };
 
   CGFloat scale = [UIScreen mainScreen].scale;
   CGFloat preferredSize = scale * [BookmarkItemCell preferredImageSize];
   CGFloat minSize = scale * minFaviconSizePt;
 
   base::CancelableTaskTracker::TaskId taskId =
       IOSChromeLargeIconServiceFactory::GetForBrowserState(self.browserState)
           ->GetLargeIconOrFallbackStyle(node->url(), minSize, preferredSize,
-                                        base::BindBlockArc(faviconBlock),
+                                        base::BindBlock(faviconBlock),
                                         &_faviconTaskTracker);
   _faviconLoadTasks[IntegerPair(indexPath.section, indexPath.item)] = taskId;
 }
 
 - (BookmarkFolderCell*)cellForFolder:(const BookmarkNode*)node
                            indexPath:(NSIndexPath*)indexPath {
   DCHECK(![self isPromoSection:indexPath.section]);
   BookmarkFolderCell* cell = [self.collectionView
       dequeueReusableCellWithReuseIdentifier:[BookmarkFolderCell
                                                  reuseIdentifier]
@@ skipping 153 matching lines @@
     return UIEdgeInsetsZero;
   }
 }
 
 - (CGSize)cellSizeForIndexPath:(NSIndexPath*)indexPath {
   if ([self isPromoSection:indexPath.section]) {
     CGRect estimatedFrame = CGRectMake(0, 0, CGRectGetWidth(self.bounds), 100);
     UICollectionViewCell* cell =
         [self.collectionView cellForItemAtIndexPath:indexPath];
     if (!cell) {
-      cell = [[BookmarkPromoCell alloc] initWithFrame:estimatedFrame];
+      cell = [[[BookmarkPromoCell alloc] initWithFrame:estimatedFrame]
+          autorelease];
     }
     cell.frame = estimatedFrame;
     [cell layoutIfNeeded];
     return [cell systemLayoutSizeFittingSize:UILayoutFittingCompressedSize];
   }
 
   UIEdgeInsets insets = [self insetForSectionAtIndex:indexPath.section];
   return CGSizeMake(self.bounds.size.width - (insets.right + insets.left),
                     rowHeight);
 }
@@ skipping 134 matching lines @@
 
 - (BOOL)shouldShowPromoCell {
   return NO;
 }
 
 - (BOOL)isPromoActive {
   return NO;
 }
 
 @end