Converts parts of ios/web to ARC

ios/web/navigation/crw_session_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/web/navigation/crw_session_controller.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <utility>
 #include <vector>
 
 #include "base/format_macros.h"
 #include "base/logging.h"
-#include "base/mac/objc_property_releaser.h"
+#import "base/mac/foundation_util.h"
 #import "base/mac/scoped_nsobject.h"
 #include "base/metrics/user_metrics.h"
 #include "base/metrics/user_metrics_action.h"
 #include "base/strings/sys_string_conversions.h"
 #import "ios/web/history_state_util.h"
 #import "ios/web/navigation/crw_session_certificate_policy_manager.h"
 #import "ios/web/navigation/crw_session_controller+private_constructors.h"
 #import "ios/web/navigation/crw_session_entry.h"
 #include "ios/web/navigation/navigation_item_impl.h"
 #import "ios/web/navigation/navigation_manager_facade_delegate.h"
@@ skipping 69 matching lines @@
 
   // The browser state associated with this CRWSessionController;
   web::BrowserState* _browserState;  // weak
 
   // Time smoother for navigation entry timestamps; see comment in
   // navigation_controller_impl.h
   web::TimeSmoother _timeSmoother;
 
   // XCallback parameters used to create (or clobber) the tab. Can be nil.
   XCallbackParameters* _xCallbackParameters;
-
-  base::mac::ObjCPropertyReleaser _propertyReleaser_CRWSessionController;
 }
 
 // Redefine as readwrite.
 @property(nonatomic, readwrite, assign) NSInteger currentNavigationIndex;
 
 // TODO(rohitrao): These properties must be redefined readwrite to work around a
 // clang bug. crbug.com/228650
-@property(nonatomic, readwrite, retain) NSString* tabId;
-@property(nonatomic, readwrite, retain) NSArray* entries;
-@property(nonatomic, readwrite, retain)
+@property(nonatomic, readwrite, copy) NSString* tabId;
+@property(nonatomic, readwrite, strong) NSArray* entries;
+@property(nonatomic, readwrite, strong)
     CRWSessionCertificatePolicyManager* sessionCertificatePolicyManager;
 
 - (NSString*)uniqueID;
 // Removes all entries after currentNavigationIndex_.
 - (void)clearForwardEntries;
 // Discards the transient entry, if any.
 - (void)discardTransientEntry;
 // Create a new autoreleased session entry.
 - (CRWSessionEntry*)sessionEntryWithURL:(const GURL&)url
                                referrer:(const web::Referrer&)referrer
@@ skipping 19 matching lines @@
 @synthesize sessionCertificatePolicyManager = _sessionCertificatePolicyManager;
 @synthesize xCallbackParameters = _xCallbackParameters;
 
 - (id)initWithWindowName:(NSString*)windowName
                 openerId:(NSString*)openerId
              openedByDOM:(BOOL)openedByDOM
    openerNavigationIndex:(NSInteger)openerIndex
             browserState:(web::BrowserState*)browserState {
   self = [super init];
   if (self) {
-    _propertyReleaser_CRWSessionController.Init(self,
-                                                [CRWSessionController class]);
     self.windowName = windowName;
-    _tabId = [[self uniqueID] retain];
+    _tabId = [[self uniqueID] copy];
     _openerId = [openerId copy];
     _openedByDOM = openedByDOM;
     _openerNavigationIndex = openerIndex;
     _browserState = browserState;
-    _entries = [[NSMutableArray array] retain];
+    _entries = [NSMutableArray array];
     _lastVisitedTimestamp = [[NSDate date] timeIntervalSince1970];
     _currentNavigationIndex = -1;
     _previousNavigationIndex = -1;
     _sessionCertificatePolicyManager =
         [[CRWSessionCertificatePolicyManager alloc] init];
   }
   return self;
 }
 
 - (id)initWithNavigationItems:(ScopedVector<web::NavigationItem>)scoped_items
                  currentIndex:(NSUInteger)currentIndex
                  browserState:(web::BrowserState*)browserState {
   self = [super init];
   if (self) {
-    _propertyReleaser_CRWSessionController.Init(self,
-                                                [CRWSessionController class]);
-    _tabId = [[self uniqueID] retain];
+    _tabId = [[self uniqueID] copy];
     _openerId = nil;
     _browserState = browserState;
 
     // Create entries array from list of navigations.
     _entries = [[NSMutableArray alloc] initWithCapacity:scoped_items.size()];
     std::vector<web::NavigationItem*> items;
     scoped_items.release(&items);
 
     for (size_t i = 0; i < items.size(); ++i) {
       std::unique_ptr<web::NavigationItem> item(items[i]);
@@ skipping 12 matching lines @@
     _lastVisitedTimestamp = [[NSDate date] timeIntervalSince1970];
     _sessionCertificatePolicyManager =
         [[CRWSessionCertificatePolicyManager alloc] init];
   }
   return self;
 }
 
 - (id)initWithCoder:(NSCoder*)aDecoder {
   self = [super init];
   if (self) {
-    _propertyReleaser_CRWSessionController.Init(self,
-                                                [CRWSessionController class]);
     NSString* uuid = [aDecoder decodeObjectForKey:kTabIdKey];
     if (!uuid)
       uuid = [self uniqueID];
 
     self.windowName = [aDecoder decodeObjectForKey:kWindowNameKey];
-    _tabId = [uuid retain];
+    _tabId = [uuid copy];
     _openerId = [[aDecoder decodeObjectForKey:kOpenerIdKey] copy];
     _openedByDOM = [aDecoder decodeBoolForKey:kOpenedByDOMKey];
     _openerNavigationIndex =
         [aDecoder decodeIntForKey:kOpenerNavigationIndexKey];
     _currentNavigationIndex =
         [aDecoder decodeIntForKey:kCurrentNavigationIndexKey];
     _previousNavigationIndex =
         [aDecoder decodeIntForKey:kPreviousNavigationIndexKey];
     _lastVisitedTimestamp =
        [aDecoder decodeDoubleForKey:kLastVisitedTimestampKey];
     NSMutableArray* temp =
         [NSMutableArray arrayWithArray:
             [aDecoder decodeObjectForKey:kEntriesKey]];
-    _entries = [temp retain];
+    _entries = temp;
     // Prior to M34, 0 was used as "no index" instead of -1; adjust for that.
     if (![_entries count])
       _currentNavigationIndex = -1;
     _sessionCertificatePolicyManager =
-       [[aDecoder decodeObjectForKey:kCertificatePolicyManagerKey] retain];
+        [aDecoder decodeObjectForKey:kCertificatePolicyManagerKey];
     if (!_sessionCertificatePolicyManager) {
       _sessionCertificatePolicyManager =
           [[CRWSessionCertificatePolicyManager alloc] init];
     }
 
     _xCallbackParameters =
-        [[aDecoder decodeObjectForKey:kXCallbackParametersKey] retain];
+        [aDecoder decodeObjectForKey:kXCallbackParametersKey];
   }
   return self;
 }
 
 - (void)encodeWithCoder:(NSCoder*)aCoder {
   [aCoder encodeObject:_tabId forKey:kTabIdKey];
   [aCoder encodeObject:_openerId forKey:kOpenerIdKey];
   [aCoder encodeBool:_openedByDOM forKey:kOpenedByDOMKey];
   [aCoder encodeInt:_openerNavigationIndex forKey:kOpenerNavigationIndexKey];
   [aCoder encodeObject:_windowName forKey:kWindowNameKey];
   [aCoder encodeInt:_currentNavigationIndex forKey:kCurrentNavigationIndexKey];
   [aCoder encodeInt:_previousNavigationIndex
              forKey:kPreviousNavigationIndexKey];
   [aCoder encodeDouble:_lastVisitedTimestamp forKey:kLastVisitedTimestampKey];
   [aCoder encodeObject:_entries forKey:kEntriesKey];
   [aCoder encodeObject:_sessionCertificatePolicyManager
                 forKey:kCertificatePolicyManagerKey];
   [aCoder encodeObject:_xCallbackParameters forKey:kXCallbackParametersKey];
   // rendererInitiated is deliberately not preserved, as upstream.
 }
 
 - (id)copyWithZone:(NSZone*)zone {
   CRWSessionController* copy = [[[self class] alloc] init];
-  copy->_propertyReleaser_CRWSessionController.Init(
-      copy, [CRWSessionController class]);
   copy->_tabId = [_tabId copy];
   copy->_openerId = [_openerId copy];
   copy->_openedByDOM = _openedByDOM;
   copy->_openerNavigationIndex = _openerNavigationIndex;
   copy.windowName = self.windowName;
   copy->_currentNavigationIndex = _currentNavigationIndex;
   copy->_previousNavigationIndex = _previousNavigationIndex;
   copy->_lastVisitedTimestamp = _lastVisitedTimestamp;
   copy->_entries =
       [[NSMutableArray alloc] initWithArray:_entries copyItems:YES];
   copy->_sessionCertificatePolicyManager =
       [_sessionCertificatePolicyManager copy];
-  copy->_xCallbackParameters = [_xCallbackParameters copy];
+  copy->_xCallbackParameters = [base::mac::ObjCCastStrict<NSObject<NSCopying>>(
+      _xCallbackParameters) copy];
   return copy;
 }
 
 - (void)setCurrentNavigationIndex:(NSInteger)currentNavigationIndex {
   if (_currentNavigationIndex != currentNavigationIndex) {
     _currentNavigationIndex = currentNavigationIndex;
     if (_navigationManager)
       _navigationManager->RemoveTransientURLRewriters();
   }
 }
@@ skipping 98 matching lines @@
       }
       return;
     }
   }
 
   BOOL useDesktopUserAgent =
       _useDesktopUserAgentForNextPendingEntry ||
       (self.currentEntry.navigationItem &&
        self.currentEntry.navigationItem->IsOverridingUserAgent());
   _useDesktopUserAgentForNextPendingEntry = NO;
-  _pendingEntry.reset([[self sessionEntryWithURL:url
-                                        referrer:ref
-                                      transition:trans
-                             useDesktopUserAgent:useDesktopUserAgent
-                               rendererInitiated:rendererInitiated] retain]);
+  _pendingEntry.reset([self sessionEntryWithURL:url
+                                       referrer:ref
+                                     transition:trans
+                            useDesktopUserAgent:useDesktopUserAgent
+                              rendererInitiated:rendererInitiated]);
 
   if (_navigationManager && _navigationManager->GetFacadeDelegate()) {
     _navigationManager->GetFacadeDelegate()->OnNavigationItemPending();
   }
 }
 
 - (void)updatePendingEntry:(const GURL&)url {
   // If there is no pending entry, navigation is probably happening within the
   // session history. Don't modify the entry list.
   if (!_pendingEntry)
@@ skipping 28 matching lines @@
   DCHECK(forwardEntryStartIndex >= 0);
 
   if (forwardEntryStartIndex >= static_cast<NSInteger>([_entries count]))
     return;
 
   NSRange remove = NSMakeRange(forwardEntryStartIndex,
                                [_entries count] - forwardEntryStartIndex);
   // Store removed items in temporary NSArray so they can be deallocated after
   // their facades.
   base::scoped_nsobject<NSArray> removedItems(
-      [[_entries subarrayWithRange:remove] retain]);
+      [_entries subarrayWithRange:remove]);
   [_entries removeObjectsInRange:remove];
   if (_previousNavigationIndex >= forwardEntryStartIndex)
     _previousNavigationIndex = -1;
   if (_navigationManager) {
     _navigationManager->OnNavigationItemsPruned(remove.length);
   }
 }
 
 - (void)commitPendingEntry {
   if (_pendingEntry) {
@@ skipping 12 matching lines @@
   web::NavigationItem* item = currentEntry.navigationItem;
   // Update the navigation timestamp now that it's actually happened.
   if (item)
     item->SetTimestamp(_timeSmoother.GetSmoothedTime(base::Time::Now()));
 
   if (_navigationManager && item)
     _navigationManager->OnNavigationItemCommitted();
 }
 
 - (void)addTransientEntryWithURL:(const GURL&)URL {
-  _transientEntry.reset(
-      [[self sessionEntryWithURL:URL
-                        referrer:web::Referrer()
-                      transition:ui::PAGE_TRANSITION_CLIENT_REDIRECT
-             useDesktopUserAgent:NO
-               rendererInitiated:NO] retain]);
+  _transientEntry.reset([self
+      sessionEntryWithURL:URL
+                 referrer:web::Referrer()
+               transition:ui::PAGE_TRANSITION_CLIENT_REDIRECT
+      useDesktopUserAgent:NO
+        rendererInitiated:NO]);
 
   web::NavigationItem* navigationItem = [_transientEntry navigationItem];
   DCHECK(navigationItem);
   navigationItem->SetTimestamp(
       _timeSmoother.GetSmoothedTime(base::Time::Now()));
 }
 
 - (void)pushNewEntryWithURL:(const GURL&)URL
                 stateObject:(NSString*)stateObject
                  transition:(ui::PageTransition)transition {
   DCHECK([self currentEntry]);
   web::NavigationItem* item = [self currentEntry].navigationItem;
   CHECK(
       web::history_state_util::IsHistoryStateChangeValid(item->GetURL(), URL));
   web::Referrer referrer(item->GetURL(), web::ReferrerPolicyDefault);
   bool overrideUserAgent =
       self.currentEntry.navigationItem->IsOverridingUserAgent();
-  base::scoped_nsobject<CRWSessionEntry> pushedEntry(
-      [[self sessionEntryWithURL:URL
-                        referrer:referrer
-                      transition:transition
-             useDesktopUserAgent:overrideUserAgent
-               rendererInitiated:NO] retain]);
+  base::scoped_nsobject<CRWSessionEntry> pushedEntry([self
+      sessionEntryWithURL:URL
+                 referrer:referrer
+               transition:transition
+      useDesktopUserAgent:overrideUserAgent
+        rendererInitiated:NO]);
   web::NavigationItemImpl* pushedItem = [pushedEntry navigationItemImpl];
   pushedItem->SetSerializedStateObject(stateObject);
   pushedItem->SetIsCreatedFromPushState(true);
   web::SSLStatus& sslStatus = [self currentEntry].navigationItem->GetSSL();
   pushedEntry.get().navigationItem->GetSSL() = sslStatus;
 
   [self clearForwardEntries];
   // Add the new entry at the end.
   [_entries addObject:pushedEntry];
   _previousNavigationIndex = _currentNavigationIndex;
@@ skipping 20 matching lines @@
   [self discardTransientEntry];
   _pendingEntry.reset();
 }
 
 - (void)discardTransientEntry {
   // Keep the entry alive temporarily. There are flows that get the current
   // entry, do some navigation operation, and then try to use that old current
   // entry; since navigations clear the transient entry, these flows might
   // crash. (This should be removable once more session management is handled
   // within this class and/or NavigationManager).
-  [[_transientEntry retain] autorelease];
   _transientEntry.reset();
 }
 
 - (BOOL)hasPendingEntry {
   return _pendingEntry != nil;
 }
 
 - (void)copyStateFromAndPrune:(CRWSessionController*)otherSession
                  replaceState:(BOOL)replaceState {
   DCHECK(otherSession);
   if (replaceState) {
     [_entries removeAllObjects];
     self.currentNavigationIndex = -1;
     _previousNavigationIndex = -1;
   }
-  self.xCallbackParameters =
-      [[otherSession.xCallbackParameters copy] autorelease];
+  self.xCallbackParameters = [base::mac::ObjCCastStrict<NSObject<NSCopying>>(
+      otherSession.xCallbackParameters) copy];
   self.windowName = otherSession.windowName;
   NSInteger numInitialEntries = [_entries count];
 
   // Cycle through the entries from the other session and insert them before any
   // entries from this session.  Do not copy anything that comes after the other
   // session's current entry unless replaceState is true.
   NSArray* otherEntries = [otherSession entries];
 
   // The other session may not have any entries, in which case there is nothing
   // to copy or prune.  The other session's currentNavigationEntry will be bogus
@@ skipping 255 matching lines @@
   else
     _useDesktopUserAgentForNextPendingEntry = YES;
 }
 
 #pragma mark -
 #pragma mark Private methods
 
 - (NSString*)uniqueID {
   CFUUIDRef uuidRef = CFUUIDCreate(NULL);
   CFStringRef uuidStringRef = CFUUIDCreateString(NULL, uuidRef);
-  CFRelease(uuidRef);
-  NSString* uuid = [NSString stringWithString:(NSString*)uuidStringRef];
+  NSString* uuid =
+      [NSString stringWithString:base::mac::ObjCCastStrict<NSString>(
+                                     CFBridgingRelease(uuidStringRef))];
   CFRelease(uuidStringRef);
   return uuid;
 }
 
 - (CRWSessionEntry*)sessionEntryWithURL:(const GURL&)url
                                referrer:(const web::Referrer&)referrer
                              transition:(ui::PageTransition)transition
                     useDesktopUserAgent:(BOOL)useDesktopUserAgent
                       rendererInitiated:(BOOL)rendererInitiated {
   GURL loaded_url(url);
   BOOL urlWasRewritten = NO;
   if (_navigationManager) {
     std::unique_ptr<std::vector<web::BrowserURLRewriter::URLRewriter>>
         transientRewriters = _navigationManager->GetTransientURLRewriters();
     if (transientRewriters) {
       urlWasRewritten = web::BrowserURLRewriter::RewriteURLWithWriters(
           &loaded_url, _browserState, *transientRewriters.get());
     }
   }
   if (!urlWasRewritten) {
     web::BrowserURLRewriter::GetInstance()->RewriteURLIfNecessary(
         &loaded_url, _browserState);
   }
   std::unique_ptr<web::NavigationItemImpl> item(new web::NavigationItemImpl());
   item->SetURL(loaded_url);
   item->SetReferrer(referrer);
   item->SetTransitionType(transition);
   item->SetIsOverridingUserAgent(useDesktopUserAgent);
   item->set_is_renderer_initiated(rendererInitiated);
-  return [[[CRWSessionEntry alloc] initWithNavigationItem:std::move(item)]
-      autorelease];
+  return [[CRWSessionEntry alloc] initWithNavigationItem:std::move(item)];
 }
 
 @end