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

ios/chrome/browser/ui/open_in_controller.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.
 
 #import "ios/chrome/browser/ui/open_in_controller.h"
 
 #include "base/files/file_path.h"
-#include "base/ios/weak_nsobject.h"
 #include "base/location.h"
 #include "base/logging.h"
 #import "base/mac/bind_objc_block.h"
-#include "base/mac/objc_property_releaser.h"
+
 #include "base/sequenced_task_runner.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/threading/thread_restrictions.h"
 #include "components/strings/grit/components_strings.h"
 #import "ios/chrome/browser/ui/alert_coordinator/alert_coordinator.h"
 #import "ios/chrome/browser/ui/open_in_controller_testing.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 "ios/web/public/web_thread.h"
 #import "ios/web/web_state/ui/crw_web_controller.h"
 #include "net/base/load_flags.h"
 #include "net/url_request/url_fetcher.h"
 #include "net/url_request/url_fetcher_delegate.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "ui/base/l10n/l10n_util_mac.h"
 #import "ui/gfx/ios/NSString+CrStringDrawing.h"
 #include "url/gurl.h"
 
+#if !defined(__has_feature) || !__has_feature(objc_arc)
+#error "This file requires ARC support."
+#endif
+
 namespace {
 // The path in the temp directory containing documents that are to be opened in
 // other applications.
 static NSString* const kDocumentsTempPath = @"OpenIn";
 
 static const int kHTTPResponseCodeSucceeded = 200;
 
 // Duration of the show/hide animation for the |openInToolbar_|.
 const NSTimeInterval kOpenInToolbarAnimationDuration = 0.2;
 
@@ skipping 14 matching lines @@
 const CGFloat kOverlayedViewLabelWidthPercentage = 0.7;
 
 // Bottom margin for the label displayed on the |overlayedView_|.
 const CGFloat kOverlayedViewLabelBottomMargin = 60;
 
 }  // anonymous namespace
 
 @interface OpenInController () {
   // AlertCoordinator for showing an alert if no applications were found to open
   // the current document.
-  base::scoped_nsobject<AlertCoordinator> _alertCoordinator;
+  AlertCoordinator* _alertCoordinator;
 }
 
 // URLFetcher delegate method called when |fetcher_| completes a request.
 - (void)urlFetchDidComplete:(const net::URLFetcher*)source;
 // Ensures the destination directory is created and any contained obsolete files
 // are deleted. Returns YES if the directory is created successfully.
 + (BOOL)createDestinationDirectoryAndRemoveObsoleteFiles;
 // Starts downloading the file at path |kDocumentsTempPath| with the name
 // |suggestedFilename_|.
 - (void)startDownload;
@@ skipping 64 matching lines @@
     // |OpenInController| destroys the fetcher and cancels the callback. This is
     // why |OnURLFetchComplete| will neved be called after |owner_| is disabled.
     owner_ = nil;
   }
 
  protected:
   friend base::RefCountedThreadSafe<OpenInControllerBridge>;
   ~OpenInControllerBridge() override {}
 
  private:
-  OpenInController* owner_;  // weak
+  __weak OpenInController* owner_;
 };
 
 @implementation OpenInController {
   // Bridge from C++ to Obj-C class.
   scoped_refptr<OpenInControllerBridge> bridge_;
 
   // URL of the document.
   GURL documentURL_;
 
   // Controller for opening documents in other applications.
-  base::scoped_nsobject<UIDocumentInteractionController> documentController_;
+  UIDocumentInteractionController* documentController_;
 
   // Toolbar overlay to be displayed on tap.
-  base::scoped_nsobject<OpenInToolbar> openInToolbar_;
+  OpenInToolbar* openInToolbar_;
 
   // Timer used to automatically hide the |openInToolbar_| after a period.
-  base::scoped_nsobject<NSTimer> openInTimer_;
+  NSTimer* openInTimer_;
 
   // Gesture recognizer to catch taps on the document.
-  base::scoped_nsobject<UITapGestureRecognizer> tapRecognizer_;
+  UITapGestureRecognizer* tapRecognizer_;
 
   // Suggested filename for the document.
-  base::scoped_nsobject<NSString> suggestedFilename_;
+  NSString* suggestedFilename_;
 
   // Fetcher used to redownload the document and save it in the sandbox.
   std::unique_ptr<net::URLFetcher> fetcher_;
 
   // CRWWebController used to check if the tap is not on a link and the
   // |openInToolbar_| should be displayed.
-  base::scoped_nsobject<CRWWebController> webController_;
+  CRWWebController* webController_;
 
   // URLRequestContextGetter needed for the URLFetcher.
   scoped_refptr<net::URLRequestContextGetter> requestContext_;
 
   // Spinner view displayed while the file is downloading.
-  base::scoped_nsobject<UIView> overlayedView_;
+  UIView* overlayedView_;
 
   // The location where the "Open in..." menu is anchored.
   CGRect anchorLocation_;
 
   // YES if the file download was canceled.
   BOOL downloadCanceled_;
 
   // YES if the OpenIn menu is displayed.
   BOOL isOpenInMenuDisplayed_;
 
   // YES if the toolbar is displayed.
   BOOL isOpenInToolbarDisplayed_;
 
   // Task runner on which file operations should happen.
   scoped_refptr<base::SequencedTaskRunner> sequencedTaskRunner_;
-
-  base::mac::ObjCPropertyReleaser propertyReleaser_OpenInController_;
 }
 
 - (id)initWithRequestContext:(net::URLRequestContextGetter*)requestContext
                webController:(CRWWebController*)webController {
   self = [super init];
   if (self) {
     requestContext_ = requestContext;
-    webController_.reset([webController retain]);
-    tapRecognizer_.reset([[UITapGestureRecognizer alloc]
+    webController_ = webController;
+    tapRecognizer_ = [[UITapGestureRecognizer alloc]
         initWithTarget:self
-                action:@selector(handleTapFrom:)]);
+                action:@selector(handleTapFrom:)];
     [tapRecognizer_ setDelegate:self];
     base::SequencedWorkerPool* pool = web::WebThread::GetBlockingPool();
     sequencedTaskRunner_ =
         pool->GetSequencedTaskRunner(pool->GetSequenceToken());
     isOpenInMenuDisplayed_ = NO;
-    propertyReleaser_OpenInController_.Init(self, [OpenInController class]);
   }
   return self;
 }
 
 - (void)enableWithDocumentURL:(const GURL&)documentURL
             suggestedFilename:(NSString*)suggestedFilename {
   documentURL_ = GURL(documentURL);
-  suggestedFilename_.reset([suggestedFilename retain]);
+  suggestedFilename_ = suggestedFilename;
   [webController_ addGestureRecognizerToWebView:tapRecognizer_];
   [self openInToolbar].alpha = 0.0f;
   [webController_ addToolbarViewToWebView:[self openInToolbar]];
   [self showOpenInToolbar];
 }
 
 - (void)disable {
   [self openInToolbar].alpha = 0.0f;
   [openInTimer_ invalidate];
   if (bridge_.get())
     bridge_->OnOwnerDisabled();
   bridge_ = nil;
   [webController_ removeGestureRecognizerFromWebView:tapRecognizer_];
   [webController_ removeToolbarViewFromWebView:[self openInToolbar]];
   [documentController_ dismissMenuAnimated:NO];
   [documentController_ setDelegate:nil];
   documentURL_ = GURL();
-  suggestedFilename_.reset();
+  suggestedFilename_ = nil;
   fetcher_.reset();
 }
 
 - (void)detachFromWebController {
   [self disable];
   // Animation blocks may be keeping this object alive; don't extend the
   // lifetime of CRWWebController.
-  webController_.reset();
+  webController_ = nil;
 }
 
 - (void)dealloc {
   [self disable];
-  [super dealloc];
 }
 
 - (void)handleTapFrom:(UIGestureRecognizer*)gestureRecognizer {
   if ([gestureRecognizer state] == UIGestureRecognizerStateEnded) {
     if (isOpenInToolbarDisplayed_) {
       [self hideOpenInToolbar];
     } else {
       [self showOpenInToolbar];
     }
   }
 }
 
 - (void)showOpenInToolbar {
   if ([openInTimer_ isValid]) {
     [openInTimer_ setFireDate:([NSDate dateWithTimeIntervalSinceNow:
                                            kOpenInToolbarDisplayDuration])];
   } else {
-    openInTimer_.reset(
-        [[NSTimer scheduledTimerWithTimeInterval:kOpenInToolbarDisplayDuration
-                                          target:self
-                                        selector:@selector(hideOpenInToolbar)
-                                        userInfo:nil
-                                         repeats:NO] retain]);
+    openInTimer_ =
+        [NSTimer scheduledTimerWithTimeInterval:kOpenInToolbarDisplayDuration
+                                         target:self
+                                       selector:@selector(hideOpenInToolbar)
+                                       userInfo:nil
+                                        repeats:NO];
     UIView* openInToolbar = [self openInToolbar];
     [UIView animateWithDuration:kOpenInToolbarAnimationDuration
                      animations:^{
                        [openInToolbar setAlpha:1.0];
                      }];
   }
   isOpenInToolbarDisplayed_ = YES;
 }
 
 - (void)hideOpenInToolbar {
@@ skipping 30 matching lines @@
   base::Callback<void(BOOL)> reply = base::Bind(
       &OpenInControllerBridge::OnDestinationDirectoryCreated, bridge_);
   base::PostTaskAndReplyWithResult(sequencedTaskRunner_.get(), FROM_HERE, task,
                                    reply);
 }
 
 - (void)startDownload {
   NSString* tempDirPath = [NSTemporaryDirectory()
       stringByAppendingPathComponent:kDocumentsTempPath];
   NSString* filePath =
-      [tempDirPath stringByAppendingPathComponent:suggestedFilename_.get()];
+      [tempDirPath stringByAppendingPathComponent:suggestedFilename_];
 
   // In iPad the toolbar has to be displayed to anchor the "Open in" menu.
   if (!IsIPadIdiom())
     [self hideOpenInToolbar];
 
   // Show an overlayed view to indicate a download is in progress. On tap this
   // view can be dismissed and the download canceled.
   [self showDownloadOverlayView];
   downloadCanceled_ = NO;
 
@@ skipping 18 matching lines @@
   [self removeOverlayedView];
   if (IsIPadIdiom())
     [self hideOpenInToolbar];
   downloadCanceled_ = YES;
 }
 
 - (void)removeOverlayedView {
   if (!overlayedView_)
     return;
 
-  UIView* overlayedView = overlayedView_.get();
+  UIView* overlayedView = overlayedView_;
   [UIView animateWithDuration:kOverlayViewAnimationDuration
       animations:^{
         [overlayedView setAlpha:0.0];
       }
       completion:^(BOOL finished) {
         [overlayedView removeFromSuperview];
       }];
-  overlayedView_.reset();
+  overlayedView_ = nil;
 }
 
 - (void)showErrorWithMessage:(NSString*)message {
   UIViewController* topViewController =
       [[[UIApplication sharedApplication] keyWindow] rootViewController];
 
-  _alertCoordinator.reset([[AlertCoordinator alloc]
-      initWithBaseViewController:topViewController
-                           title:nil
-                         message:message]);
+  _alertCoordinator =
+      [[AlertCoordinator alloc] initWithBaseViewController:topViewController
+                                                     title:nil
+                                                   message:message];
 
   [_alertCoordinator addItemWithTitle:l10n_util::GetNSString(IDS_OK)
                                action:nil
                                 style:UIAlertActionStyleDefault];
 
   [_alertCoordinator start];
 }
 
 - (void)presentOpenInMenuForFileAtURL:(NSURL*)fileURL {
   if (!webController_)
     return;
 
   if (requestContext_.get()) {
     // |requestContext_| is nil only if this is called from a unit test, in
     // which case the |documentController_| was set already.
-    documentController_.reset([[UIDocumentInteractionController
-        interactionControllerWithURL:fileURL] retain]);
+    documentController_ =
+        [UIDocumentInteractionController interactionControllerWithURL:fileURL];
   }
 
   // TODO(cgrigoruta): The UTI is hardcoded for now, change this when we add
   // support for other file types as well.
   [documentController_ setUTI:@"com.adobe.pdf"];
   [documentController_ setDelegate:self];
   BOOL success =
       [documentController_ presentOpenInMenuFromRect:anchorLocation_
                                               inView:[webController_ view]
                                             animated:YES];
   if (requestContext_.get()) {
     [self removeOverlayedView];
     if (!success) {
       if (IsIPadIdiom())
         [self hideOpenInToolbar];
       NSString* errorMessage =
           l10n_util::GetNSStringWithFixup(IDS_IOS_OPEN_IN_NO_APPS_REGISTERED);
       [self showErrorWithMessage:errorMessage];
     } else {
       isOpenInMenuDisplayed_ = YES;
     }
   }
 }
 
 - (void)showDownloadOverlayView {
   UIViewController* topViewController =
       [[[UIApplication sharedApplication] keyWindow] rootViewController];
   UIView* topView = topViewController.view;
-  overlayedView_.reset([[UIView alloc] initWithFrame:[topView bounds]]);
+  overlayedView_ = [[UIView alloc] initWithFrame:[topView bounds]];
   [overlayedView_ setAutoresizingMask:(UIViewAutoresizingFlexibleWidth |
                                        UIViewAutoresizingFlexibleHeight)];
-  base::scoped_nsobject<UIView> grayBackgroundView(
-      [[UIView alloc] initWithFrame:[overlayedView_ frame]]);
+  UIView* grayBackgroundView =
+      [[UIView alloc] initWithFrame:[overlayedView_ frame]];
   [grayBackgroundView setBackgroundColor:[UIColor darkGrayColor]];
   [grayBackgroundView setAlpha:kOverlayedViewBackgroundAlpha];
   [grayBackgroundView setAutoresizingMask:(UIViewAutoresizingFlexibleWidth |
                                            UIViewAutoresizingFlexibleHeight)];
   [overlayedView_ addSubview:grayBackgroundView];
 
-  base::scoped_nsobject<UIActivityIndicatorView> spinner([
-      [UIActivityIndicatorView alloc]
-      initWithActivityIndicatorStyle:UIActivityIndicatorViewStyleWhiteLarge]);
+  UIActivityIndicatorView* spinner = [[UIActivityIndicatorView alloc]
+      initWithActivityIndicatorStyle:UIActivityIndicatorViewStyleWhiteLarge];
   [spinner setFrame:[overlayedView_ frame]];
   [spinner setHidesWhenStopped:YES];
   [spinner setUserInteractionEnabled:NO];
   [spinner startAnimating];
   [spinner setAutoresizingMask:(UIViewAutoresizingFlexibleWidth |
                                 UIViewAutoresizingFlexibleHeight)];
   [overlayedView_ addSubview:spinner];
 
-  base::scoped_nsobject<UILabel> label([[UILabel alloc] init]);
+  UILabel* label = [[UILabel alloc] init];
   [label setTextColor:[UIColor whiteColor]];
   [label setFont:GetUIFont(FONT_HELVETICA, true, kLabelTextSize)];
   [label setNumberOfLines:0];
   [label setShadowColor:[UIColor blackColor]];
   [label setShadowOffset:CGSizeMake(0.0, 1.0)];
   [label setBackgroundColor:[UIColor clearColor]];
   [label setText:l10n_util::GetNSString(IDS_IOS_OPEN_IN_FILE_DOWNLOAD_CANCEL)];
   [label setLineBreakMode:NSLineBreakByWordWrapping];
   [label setTextAlignment:NSTextAlignmentCenter];
   CGFloat labelWidth =
       [overlayedView_ frame].size.width * kOverlayedViewLabelWidthPercentage;
   CGFloat originX = ([overlayedView_ frame].size.width - labelWidth) / 2;
 
   CGFloat labelHeight =
       [[label text] cr_boundingSizeWithSize:CGSizeMake(labelWidth, CGFLOAT_MAX)
                                        font:[label font]]
           .height;
   CGFloat originY =
       [overlayedView_ center].y - labelHeight - kOverlayedViewLabelBottomMargin;
   [label setFrame:CGRectMake(originX, originY, labelWidth, labelHeight)];
   [overlayedView_ addSubview:label];
 
-  base::scoped_nsobject<UITapGestureRecognizer> tapRecognizer(
-      [[UITapGestureRecognizer alloc]
-          initWithTarget:self
-                  action:@selector(handleTapOnOverlayedView:)]);
+  UITapGestureRecognizer* tapRecognizer = [[UITapGestureRecognizer alloc]
+      initWithTarget:self
+              action:@selector(handleTapOnOverlayedView:)];
   [tapRecognizer setDelegate:self];
   [overlayedView_ addGestureRecognizer:tapRecognizer];
 
   [overlayedView_ setAlpha:0.0];
   [topView addSubview:overlayedView_];
-  UIView* overlayedView = overlayedView_.get();
+  UIView* overlayedView = overlayedView_;
   [UIView animateWithDuration:kOverlayViewAnimationDuration
                    animations:^{
                      [overlayedView setAlpha:1.0];
                    }];
 }
 
 - (UIView*)openInToolbar {
   if (!openInToolbar_) {
-    openInToolbar_.reset([[OpenInToolbar alloc]
+    openInToolbar_ = [[OpenInToolbar alloc]
         initWithTarget:self
-                action:@selector(exportFileWithOpenInMenuAnchoredAt:)]);
+                action:@selector(exportFileWithOpenInMenuAnchoredAt:)];
   }
-  return openInToolbar_.get();
+  return openInToolbar_;
 }
 
 #pragma mark -
 #pragma mark File management
 
 - (void)removeDocumentAtPath:(NSString*)path {
   base::ThreadRestrictions::AssertIOAllowed();
   NSFileManager* fileManager = [NSFileManager defaultManager];
   NSError* error = nil;
   if (![fileManager removeItemAtPath:path error:&error]) {
@@ skipping 59 matching lines @@
 - (void)urlFetchDidComplete:(const net::URLFetcher*)fetcher {
   DCHECK(fetcher);
   if (requestContext_.get())
     DCHECK_CURRENTLY_ON(web::WebThread::UI);
   base::FilePath filePath;
   if (fetcher->GetResponseCode() == kHTTPResponseCodeSucceeded &&
       fetcher->GetResponseAsFilePath(true, &filePath)) {
     NSURL* fileURL =
         [NSURL fileURLWithPath:base::SysUTF8ToNSString(filePath.value())];
     if (downloadCanceled_) {
-      sequencedTaskRunner_->PostTask(FROM_HERE, base::BindBlock(^{
+      sequencedTaskRunner_->PostTask(FROM_HERE, base::BindBlockArc(^{
                                        [self
                                            removeDocumentAtPath:[fileURL path]];
                                      }));
     } else {
       [self presentOpenInMenuForFileAtURL:fileURL];
     }
   } else if (!downloadCanceled_) {
     if (IsIPadIdiom())
       [self hideOpenInToolbar];
     [self removeOverlayedView];
     [self showErrorWithMessage:l10n_util::GetNSStringWithFixup(
                                    IDS_IOS_OPEN_IN_FILE_DOWNLOAD_FAILED)];
   }
 }
 
 #pragma mark -
 #pragma mark UIDocumentInteractionControllerDelegate Methods
 
 - (void)documentInteractionController:(UIDocumentInteractionController*)contr
            didEndSendingToApplication:(NSString*)application {
-  sequencedTaskRunner_->PostTask(FROM_HERE, base::BindBlock(^{
+  sequencedTaskRunner_->PostTask(FROM_HERE, base::BindBlockArc(^{
                                    [self
                                        removeDocumentAtPath:[[contr URL] path]];
                                  }));
   if (IsIPadIdiom()) {
     // Call the |documentInteractionControllerDidDismissOpenInMenu:| method
     // as this is not called on the iPad after the document has been opened
     // in another application.
     [self documentInteractionControllerDidDismissOpenInMenu:contr];
   }
 }
 
 - (void)documentInteractionControllerDidDismissOpenInMenu:
     (UIDocumentInteractionController*)controller {
   if (!IsIPadIdiom()) {
     isOpenInMenuDisplayed_ = NO;
     // On the iPhone the |openInToolber_| is hidden already.
     return;
   }
 
   // On iPad this method is called whenever the device changes orientation,
   // even thought the OpenIn menu is not displayed. To distinguish the cases
   // when this method is called after the OpenIn menu is dismissed, we
   // check the BOOL |isOpenInMenuDisplayed|.
   if (isOpenInMenuDisplayed_) {
-    openInTimer_.reset(
-        [[NSTimer scheduledTimerWithTimeInterval:kOpenInToolbarDisplayDuration
-                                          target:self
-                                        selector:@selector(hideOpenInToolbar)
-                                        userInfo:nil
-                                         repeats:NO] retain]);
+    openInTimer_ =
+        [NSTimer scheduledTimerWithTimeInterval:kOpenInToolbarDisplayDuration
+                                         target:self
+                                       selector:@selector(hideOpenInToolbar)
+                                       userInfo:nil
+                                        repeats:NO];
   }
   isOpenInMenuDisplayed_ = NO;
 }
 
 #pragma mark -
 #pragma mark UIGestureRecognizerDelegate Methods
 
 - (BOOL)gestureRecognizerShouldBegin:(UIGestureRecognizer*)gestureRecognizer {
   if ([gestureRecognizer.view isEqual:overlayedView_])
     return YES;
 
   CGPoint location = [gestureRecognizer locationInView:[self openInToolbar]];
   return ![[self openInToolbar] pointInside:location withEvent:nil];
 }
 
 #pragma mark - TestingAditions
 
 - (void)setDocumentInteractionController:
     (UIDocumentInteractionController*)controller {
-  documentController_.reset([controller retain]);
+  documentController_ = controller;
 }
 
 - (NSString*)suggestedFilename {
-  return suggestedFilename_.get();
+  return suggestedFilename_;
 }
 
 @end