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

ios/chrome/browser/ui/bookmarks/bookmark_utils_ios.mm

 // Copyright (c) 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_utils_ios.h"
 
 #include <stdint.h>
 
 #include <memory>
 #include <vector>
 
 #include "base/hash.h"
 #include "base/i18n/string_compare.h"
 #include "base/mac/bind_objc_block.h"
-#include "base/mac/scoped_nsautorelease_pool.h"
-#include "base/mac/scoped_nsobject.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/user_metrics_action.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "components/bookmarks/browser/bookmark_model.h"
 #include "components/query_parser/query_parser.h"
 #include "components/strings/grit/components_strings.h"
 #include "ios/chrome/browser/bookmarks/bookmarks_utils.h"
 #include "ios/chrome/browser/experimental_flags.h"
 #import "ios/chrome/browser/ui/bookmarks/bookmark_collection_cells.h"
 #import "ios/chrome/browser/ui/bookmarks/bookmark_menu_item.h"
 #import "ios/chrome/browser/ui/bookmarks/bookmark_position_cache.h"
 #include "ios/chrome/browser/ui/bookmarks/undo_manager_wrapper.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"
 #import "ios/third_party/material_components_ios/src/components/Snackbar/src/MaterialSnackbar.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/l10n/l10n_util_mac.h"
 #include "ui/base/models/tree_node_iterator.h"
 
+#if !defined(__has_feature) || !__has_feature(objc_arc)
+#error "This file requires ARC support."
+#endif
+
 using bookmarks::BookmarkNode;
 
 namespace bookmark_utils_ios {
 
 namespace {
 
 const BookmarkNode* FindFolderById(bookmarks::BookmarkModel* model,
                                    int64_t id) {
   ui::TreeNodeIterator<const BookmarkNode> iterator(model->root_node());
   while (iterator.has_next()) {
@@ skipping 131 matching lines @@
     return CGRectGetWidth(statusBarWindowRect);
   }
 }
 
 BOOL bookmarkMenuIsInSlideInPanel() {
   return !IsIPadIdiom() || IsCompactTablet();
 }
 
 UIView* dropShadowWithWidth(CGFloat width) {
   UIImage* shadowImage = [UIImage imageNamed:@"bookmark_bar_shadow"];
-  UIImageView* shadow =
-      [[[UIImageView alloc] initWithImage:shadowImage] autorelease];
+  UIImageView* shadow = [[UIImageView alloc] initWithImage:shadowImage];
   CGRect shadowFrame = CGRectMake(0, 0, width, 4);
   shadow.frame = shadowFrame;
   shadow.autoresizingMask =
       UIViewAutoresizingFlexibleTopMargin | UIViewAutoresizingFlexibleWidth;
   return shadow;
 }
 
 #pragma mark - Updating Bookmarks
 
 // Deletes all subnodes of |node|, including |node|, that are in |bookmarks|.
@@ skipping 16 matching lines @@
   DCHECK(!node || node->is_url());
   base::string16 titleString = base::SysNSStringToUTF16(title);
 
   // If the bookmark has no changes supporting Undo, just bail out.
   if (node && node->GetTitle() == titleString && node->url() == url &&
       node->parent() == folder) {
     return;
   }
 
   // Secondly, create an Undo group for all undoable actions.
-  base::scoped_nsobject<UndoManagerWrapper> wrapper(
-      [[UndoManagerWrapper alloc] initWithBrowserState:browser_state]);
+  UndoManagerWrapper* wrapper =
+      [[UndoManagerWrapper alloc] initWithBrowserState:browser_state];
 
   // Create or update the bookmark.
   [wrapper startGroupingActions];
 
   // Save the bookmark information.
   if (!node) {  // Create a new bookmark.
     bookmark_model->client()->RecordAction(
         base::UserMetricsAction("BookmarkAdded"));
     node =
         bookmark_model->AddURL(folder, folder->child_count(), titleString, url);
@@ skipping 13 matching lines @@
   [wrapper resetUndoManagerChanged];
 
   NSString* text =
       l10n_util::GetNSString((node) ? IDS_IOS_BOOKMARK_NEW_BOOKMARK_UPDATED
                                     : IDS_IOS_BOOKMARK_NEW_BOOKMARK_CREATED);
   PresentUndoToastWithWrapper(wrapper, text);
 }
 
 void PresentUndoToastWithWrapper(UndoManagerWrapper* wrapper, NSString* text) {
   // Create the block that will be executed if the user taps the undo button.
-  MDCSnackbarMessageAction* action =
-      [[[MDCSnackbarMessageAction alloc] init] autorelease];
+  MDCSnackbarMessageAction* action = [[MDCSnackbarMessageAction alloc] init];
   action.handler = ^{
     if (![wrapper hasUndoManagerChanged])
       [wrapper undo];
   };
 
   action.title = l10n_util::GetNSString(IDS_IOS_BOOKMARK_NEW_UNDO_BUTTON_TITLE);
   action.accessibilityIdentifier = @"Undo";
   action.accessibilityLabel =
       l10n_util::GetNSString(IDS_IOS_BOOKMARK_NEW_UNDO_BUTTON_TITLE);
   TriggerHapticFeedbackForNotification(UINotificationFeedbackTypeSuccess);
@@ skipping 20 matching lines @@
   if (bookmarks.find(node) != bookmarks.end())
     model->Remove(node);
 }
 
 void DeleteBookmarksWithUndoToast(const std::set<const BookmarkNode*>& nodes,
                                   bookmarks::BookmarkModel* model,
                                   ios::ChromeBrowserState* browser_state) {
   size_t nodeCount = nodes.size();
   DCHECK_GT(nodeCount, 0u);
 
-  base::scoped_nsobject<UndoManagerWrapper> wrapper(
-      [[UndoManagerWrapper alloc] initWithBrowserState:browser_state]);
+  UndoManagerWrapper* wrapper =
+      [[UndoManagerWrapper alloc] initWithBrowserState:browser_state];
 
   // Delete the selected bookmarks.
   [wrapper startGroupingActions];
   bookmark_utils_ios::DeleteBookmarks(nodes, model);
   [wrapper stopGroupingActions];
   [wrapper resetUndoManagerChanged];
 
   NSString* text = nil;
 
   if (nodeCount == 1) {
@@ skipping 30 matching lines @@
   return didPerformMove;
 }
 
 void MoveBookmarksWithUndoToast(const std::set<const BookmarkNode*>& nodes,
                                 bookmarks::BookmarkModel* model,
                                 const BookmarkNode* folder,
                                 ios::ChromeBrowserState* browser_state) {
   size_t nodeCount = nodes.size();
   DCHECK_GT(nodeCount, 0u);
 
-  base::scoped_nsobject<UndoManagerWrapper> wrapper(
-      [[UndoManagerWrapper alloc] initWithBrowserState:browser_state]);
+  UndoManagerWrapper* wrapper =
+      [[UndoManagerWrapper alloc] initWithBrowserState:browser_state];
 
   // Move the selected bookmarks.
   [wrapper startGroupingActions];
   bool didPerformMove = bookmark_utils_ios::MoveBookmarks(nodes, model, folder);
   [wrapper stopGroupingActions];
   [wrapper resetUndoManagerChanged];
 
   if (!didPerformMove)
     return;  // Don't present a snackbar when no real move as happened.
 
@@ skipping 28 matching lines @@
 NodesSection::NodesSection() {}
 
 NodesSection::~NodesSection() {}
 
 void segregateNodes(
     const NodeVector& vector,
     std::vector<std::unique_ptr<NodesSection>>& nodesSectionVector) {
   nodesSectionVector.clear();
 
   // Make a localized date formatter.
-  base::scoped_nsobject<NSDateFormatter> formatter(
-      [[NSDateFormatter alloc] init]);
+  NSDateFormatter* formatter = [[NSDateFormatter alloc] init];
   [formatter setDateFormat:@"MMMM yyyy"];
   // Segregate nodes by creation date.
   // Nodes that were created in the same month are grouped together.
   for (auto* node : vector) {
-    base::mac::ScopedNSAutoreleasePool pool;
-    base::Time dateAdded = node->date_added();
-    base::TimeDelta delta = dateAdded - base::Time::UnixEpoch();
-    base::scoped_nsobject<NSDate> date(
-        [[NSDate alloc] initWithTimeIntervalSince1970:delta.InSeconds()]);
-    NSString* dateString = [formatter stringFromDate:date];
-    const std::string timeRepresentation = base::SysNSStringToUTF8(dateString);
+    @autoreleasepool {
+      base::Time dateAdded = node->date_added();
+      base::TimeDelta delta = dateAdded - base::Time::UnixEpoch();
+      NSDate* date =
+          [[NSDate alloc] initWithTimeIntervalSince1970:delta.InSeconds()];
+      NSString* dateString = [formatter stringFromDate:date];
+      const std::string timeRepresentation =
+          base::SysNSStringToUTF8(dateString);
 
-    BOOL found = NO;
-    for (const auto& nodesSection : nodesSectionVector) {
-      if (nodesSection->timeRepresentation == timeRepresentation) {
-        nodesSection->vector.push_back(node);
-        found = YES;
-        break;
+      BOOL found = NO;
+      for (const auto& nodesSection : nodesSectionVector) {
+        if (nodesSection->timeRepresentation == timeRepresentation) {
+          nodesSection->vector.push_back(node);
+          found = YES;
+          break;
+        }
       }
+
+      if (found)
+        continue;
+
+      // No NodesSection found.
+      auto nodesSection = base::MakeUnique<NodesSection>();
+      nodesSection->time = dateAdded;
+      nodesSection->timeRepresentation = timeRepresentation;
+      nodesSection->vector.push_back(node);
+      nodesSectionVector.push_back(std::move(nodesSection));
     }
-
-    if (found)
-      continue;
-
-    // No NodesSection found.
-    auto nodesSection = base::MakeUnique<NodesSection>();
-    nodesSection->time = dateAdded;
-    nodesSection->timeRepresentation = timeRepresentation;
-    nodesSection->vector.push_back(node);
-    nodesSectionVector.push_back(std::move(nodesSection));
   }
 
   // Sort the NodesSections.
   std::sort(nodesSectionVector.begin(), nodesSectionVector.end(),
             [](const std::unique_ptr<NodesSection>& n1,
                const std::unique_ptr<NodesSection>& n2) {
               return n1->time > n2->time;
             });
 
   // For each NodesSection, sort the nodes inside.
@@ skipping 227 matching lines @@
 
   *position = cache.position;
   return YES;
 }
 
 void ClearPositionCache() {
   [[NSUserDefaults standardUserDefaults] removeObjectForKey:kPositionCacheKey];
 }
 
 }  // namespace bookmark_utils_ios