WebStateList is an array of web::WebState* wrappers.

ios/chrome/browser/tabs/tab_model.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/tabs/tab_model.h"
 
 #include <list>
 #include <utility>
 #include <vector>
 
@@ skipping 48 matching lines @@
     @"kTabModelTabDeselectedNotification";
 NSString* const kTabModelNewTabWillOpenNotification =
     @"kTabModelNewTabWillOpenNotification";
 NSString* const kTabModelTabKey = @"tab";
 NSString* const kTabModelPageLoadSuccess = @"pageLoadSuccess";
 NSString* const kTabModelOpenInBackgroundKey = @"shouldOpenInBackground";
 
 namespace {
 
 // Updates CRWSessionCertificatePolicyManager's certificate policy cache.
-void UpdateCertificatePolicyCacheFromWebState(web::WebStateImpl* webState) {
+void UpdateCertificatePolicyCacheFromWebState(web::WebStateImpl* web_state) {
   DCHECK([NSThread isMainThread]);
-  DCHECK(webState);
+  DCHECK(web_state);
   scoped_refptr<web::CertificatePolicyCache> policy_cache =
-      web::BrowserState::GetCertificatePolicyCache(webState->GetBrowserState());
+      web::BrowserState::GetCertificatePolicyCache(
+          web_state->GetBrowserState());
   CRWSessionController* controller =
-      webState->GetNavigationManagerImpl().GetSessionController();
+      web_state->GetNavigationManagerImpl().GetSessionController();
   [[controller sessionCertificatePolicyManager]
       updateCertificatePolicyCache:policy_cache];
 }
 
 // Populates the certificate policy cache based on the current entries of the
 // given tabs.
-void RestoreCertificatePolicyCacheFromTabs(NSArray* tabs) {
+void RestoreCertificatePolicyCacheFromTabs(WebStateList* web_state_list) {
   DCHECK([NSThread isMainThread]);
-  for (Tab* tab in tabs) {
-    UpdateCertificatePolicyCacheFromWebState(tab.webStateImpl);
+  for (id<WebStateHandle> web_state in web_state_list) {
+    UpdateCertificatePolicyCacheFromWebState(web_state.webStateImpl);
   }
 }
 
 // Scrubs the certificate policy cache of all the certificate policies except
 // those for the current entries of the given tabs.
 void CleanCertificatePolicyCache(
     scoped_refptr<web::CertificatePolicyCache> policy_cache,
-    NSArray* tabs) {
+    WebStateList* web_state_list) {
   DCHECK_CURRENTLY_ON(web::WebThread::IO);
   DCHECK(policy_cache);
   policy_cache->ClearCertificatePolicies();
   web::WebThread::PostTask(
       web::WebThread::UI, FROM_HERE,
-      base::Bind(&RestoreCertificatePolicyCacheFromTabs, tabs));
+      base::Bind(&RestoreCertificatePolicyCacheFromTabs, web_state_list));
+}
+
+// Creates a NSArray<Tab*>* from |web_state_list|. This is for compatibility
+// with TabUsageRecorder existing API. That API will be refactored in later
+// CL and this method removed, see http://crbug.com/681867 for details.
+NSArray<Tab*>* GetTabsFromWebStateList(WebStateList* web_state_list) {
+  NSMutableArray<Tab*>* mutableArray = [[NSMutableArray alloc] init];
+  for (Tab* tab in web_state_list) {
+    [mutableArray addObject:tab];
+  }
+  return [mutableArray copy];
 }
 
 }  // anonymous namespace
 
 @interface TabModelObservers : CRBProtocolObservers<TabModelObserver>
 @end
 @implementation TabModelObservers
 @end
 
 @interface TabModel ()<TabUsageRecorderDelegate> {
-  // Array of |Tab| objects.
-  base::scoped_nsobject<NSMutableArray> _tabs;
   // Maintains policy for where new tabs go and the selection when a tab
   // is removed.
   base::scoped_nsobject<TabModelOrderController> _orderController;
   // The delegate for sync.
   std::unique_ptr<TabModelSyncedWindowDelegate> _syncedWindowDelegate;
   // Currently selected tab. May be nil.
   base::WeakNSObject<Tab> _currentTab;
 
   // Counters for metrics.
   int _openedTabCount;
@@ skipping 68 matching lines @@
   [super dealloc];
 }
 
 #pragma mark - Public methods
 
 - (Tab*)currentTab {
   return _currentTab.get();
 }
 
 - (void)setCurrentTab:(Tab*)newTab {
-  DCHECK([_tabs containsObject:newTab]);
+  DCHECK([self containsWebState:newTab]);
   if (_currentTab != newTab) {
     base::RecordAction(base::UserMetricsAction("MobileTabSwitched"));
     [self updateSnapshotCache:newTab];
   }
   if (_tabUsageRecorder) {
     _tabUsageRecorder->RecordTabSwitched(_currentTab, newTab);
   }
   [self changeSelectedTabFrom:_currentTab to:newTab persistState:YES];
 }
 
 - (TabModelSyncedWindowDelegate*)syncedWindowDelegate {
   return _syncedWindowDelegate.get();
 }
 
 - (TabUsageRecorder*)tabUsageRecorder {
   return _tabUsageRecorder.get();
 }
 
 - (BOOL)isOffTheRecord {
   return _browserState && _browserState->IsOffTheRecord();
 }
 
 - (BOOL)isEmpty {
   return self.count == 0;
 }
 
-- (NSUInteger)count {
-  return [_tabs count];
-}
-
 - (instancetype)initWithSessionWindow:(SessionWindowIOS*)window
                        sessionService:(SessionServiceIOS*)service
                          browserState:(ios::ChromeBrowserState*)browserState {
   if ((self = [super init])) {
     _observers.reset([[TabModelObservers
         observersWithProtocol:@protocol(TabModelObserver)] retain]);
 
     _browserState = browserState;
     DCHECK(_browserState);
 
     // There must be a valid session service defined to consume session windows.
     DCHECK(service);
     _sessionService.reset([service retain]);
 
     // Normal browser states are the only ones to get tab restore. Tab sync
     // handles incognito browser states by filtering on profile, so it's
     // important to the backend code to always have a sync window delegate.
     if (!_browserState->IsOffTheRecord()) {
       // Set up the usage recorder before tabs are created.
       _tabUsageRecorder.reset(new TabUsageRecorder(self));
     }
     _syncedWindowDelegate.reset(new TabModelSyncedWindowDelegate(self));
 
-    _tabs.reset([[NSMutableArray alloc] init]);
     NSNotificationCenter* defaultCenter = [NSNotificationCenter defaultCenter];
     if (window) {
       while (window.unclaimedSessions) {
         std::unique_ptr<web::WebStateImpl> webState = [window nextSession];
         DCHECK_EQ(webState->GetBrowserState(), _browserState);
         // Restore the CertificatePolicyCache.
         UpdateCertificatePolicyCacheFromWebState(webState.get());
         // Create a new tab for each entry in the window. Don't send delegate
         // notifications for each restored tab, only when all done.
         base::scoped_nsobject<Tab> tab(
             [[Tab alloc] initWithWebState:std::move(webState) model:self]);
         [tab webController].usePlaceholderOverlay = YES;
         [tab fetchFavicon];
-        [_tabs addObject:tab];
+        [self addWebState:tab];
 
         TabParentingGlobalObserver::GetInstance()->OnTabParented(
             [tab webStateImpl]);
       }
-      if ([_tabs count]) {
-        DCHECK(window.selectedIndex < [_tabs count]);
+      if (self.count) {
+        DCHECK(window.selectedIndex < self.count);
         _currentTab.reset([self tabAtIndex:window.selectedIndex]);
         DCHECK(_currentTab);
-        if (_tabUsageRecorder)
-          _tabUsageRecorder->InitialRestoredTabs(_currentTab, _tabs);
+        if (_tabUsageRecorder) {
+          _tabUsageRecorder->InitialRestoredTabs(_currentTab,
+                                                 GetTabsFromWebStateList(self));
+        }
         // Perform initializations for affiliated objects which update the
         // session information related to the current tab.
         [_currentTab updateLastVisitedTimestamp];
         [self saveSessionImmediately:NO];
       }
     }
 
     _orderController.reset(
         [[TabModelOrderController alloc] initWithTabModel:self]);
     // Register for resign active notification.
@@ skipping 21 matching lines @@
 - (instancetype)init {
   NOTREACHED();
   return nil;
 }
 
 - (BOOL)restoreSessionWindow:(SessionWindowIOS*)window {
   DCHECK(_browserState);
   DCHECK(window);
   if (!window.unclaimedSessions)
     return NO;
-  size_t oldCount = [_tabs count];
+  size_t oldCount = self.count;
   size_t index = oldCount;
   while (window.unclaimedSessions) {
     std::unique_ptr<web::WebStateImpl> webState = [window nextSession];
     DCHECK_EQ(webState->GetBrowserState(), _browserState);
     Tab* tab = [self insertTabWithWebState:std::move(webState) atIndex:index++];
     tab.webController.usePlaceholderOverlay = YES;
     // Restore the CertificatePolicyCache. Note that after calling Pass()
     // |webState| is invalid, so we need to get the webstate from |tab|.
     UpdateCertificatePolicyCacheFromWebState(tab.webStateImpl);
   }
-  DCHECK([_tabs count] > oldCount);
+  DCHECK(self.count > oldCount);
   // If any tab was restored, the saved selected tab must be selected.
-  if ([_tabs count] > oldCount) {
+  if (self.count > oldCount) {
     NSUInteger selectedIndex = window.selectedIndex;
     if (selectedIndex == NSNotFound)
       selectedIndex = oldCount;
     else
       selectedIndex += oldCount;
-    DCHECK(selectedIndex < [_tabs count]);
+    DCHECK(selectedIndex < self.count);
     Tab* newTab = [self tabAtIndex:selectedIndex];
     DCHECK(newTab);
     [self changeSelectedTabFrom:_currentTab to:newTab persistState:YES];
 
     // If there was only one tab and it was the new tab page, clobber it.
     if (oldCount == 1) {
-      Tab* tab = [_tabs objectAtIndex:0];
+      Tab* tab = [self firstWebState];
       if (tab.url == GURL(kChromeUINewTabURL)) {
         [self closeTab:tab];
-        if (_tabUsageRecorder)
-          _tabUsageRecorder->InitialRestoredTabs(_currentTab, _tabs);
+        if (_tabUsageRecorder) {
+          _tabUsageRecorder->InitialRestoredTabs(_currentTab,
+                                                 GetTabsFromWebStateList(self));
+        }
         return YES;
       }
     }
     if (_tabUsageRecorder) {
       _tabUsageRecorder->InitialRestoredTabs(
           _currentTab,
-          [_tabs subarrayWithRange:NSMakeRange(oldCount,
-                                               [_tabs count] - oldCount)]);
+          [GetTabsFromWebStateList(self)
+              subarrayWithRange:NSMakeRange(oldCount, self.count - oldCount)]);
     }
   }
   return NO;
 }
 
 - (void)saveSessionImmediately:(BOOL)immediately {
   // Do nothing if there are tabs in the model but no selected tab. This is
   // a transitional state.
-  if ((!_currentTab && [_tabs count]) || !_browserState)
+  if ((!_currentTab && self.count) || !_browserState)
     return;
   [_sessionService saveWindow:self.windowForSavingSession
               forBrowserState:_browserState
                   immediately:immediately];
 }
 
 - (Tab*)tabAtIndex:(NSUInteger)index {
-  return [_tabs objectAtIndex:index];
+  return [self webStateAtIndex:index];
 }
 
 - (NSUInteger)indexOfTab:(Tab*)tab {
-  return [_tabs indexOfObject:tab];
+  return [self indexOfWebState:tab];
 }
 
 - (Tab*)tabWithWindowName:(NSString*)windowName {
   if (!windowName)
     return nil;
-  for (Tab* tab in _tabs.get()) {
+  for (Tab* tab in self) {
     if ([windowName isEqualToString:tab.windowName]) {
       return tab;
     }
   }
   return nil;
 }
 
 - (Tab*)nextTabWithOpener:(Tab*)tab afterTab:(Tab*)afterTab {
   NSUInteger startIndex = NSNotFound;
   // Start looking after |afterTab|. If it's not found, start looking after
   // |tab|. If it's not found either, bail.
   if (afterTab)
     startIndex = [self indexOfTab:afterTab];
   if (startIndex == NSNotFound)
     startIndex = [self indexOfTab:tab];
   if (startIndex == NSNotFound)
     return nil;
   NSString* parentID = [tab currentSessionID];
-  for (NSUInteger i = startIndex + 1; i < [_tabs count]; ++i) {
-    Tab* current = [_tabs objectAtIndex:i];
+  for (NSUInteger i = startIndex + 1; i < self.count; ++i) {
+    Tab* current = [self webStateAtIndex:i];
     DCHECK([current navigationManager]);
     CRWSessionController* sessionController =
         [current navigationManager]->GetSessionController();
     if ([sessionController.openerId isEqualToString:parentID])
       return current;
   }
   return nil;
 }
 
 - (Tab*)firstTabWithOpener:(Tab*)tab {
   if (!tab)
     return nil;
   NSUInteger stopIndex = [self indexOfTab:tab];
   if (stopIndex == NSNotFound)
     return nil;
   NSString* parentID = [tab currentSessionID];
   // Match the navigation index as well as the session id, to better match the
   // state of the tab. I.e. two tabs are opened via a link from tab A, and then
   // a new url is loaded into tab A, and more tabs opened from that url, the
   // latter two tabs should not be grouped with the former two. The navigation
   // index is the simplest way to detect navigation changes.
   DCHECK([tab navigationManager]);
   NSInteger parentNavIndex = [tab navigationManager]->GetCurrentItemIndex();
   for (NSUInteger i = 0; i < stopIndex; ++i) {
-    Tab* tabToCheck = [_tabs objectAtIndex:i];
+    Tab* tabToCheck = [self webStateAtIndex:i];
     DCHECK([tabToCheck navigationManager]);
     CRWSessionController* sessionController =
         [tabToCheck navigationManager]->GetSessionController();
     if ([sessionController.openerId isEqualToString:parentID] &&
         sessionController.openerNavigationIndex == parentNavIndex) {
       return tabToCheck;
     }
   }
   return nil;
 }
 
 - (Tab*)lastTabWithOpener:(Tab*)tab {
   NSUInteger startIndex = [self indexOfTab:tab];
   if (startIndex == NSNotFound)
     return nil;
   // There is at least one tab in the model, because otherwise the above check
   // would have returned.
   NSString* parentID = [tab currentSessionID];
   DCHECK([tab navigationManager]);
   NSInteger parentNavIndex = [tab navigationManager]->GetCurrentItemIndex();
 
   Tab* match = nil;
   // Find the last tab in the first matching 'group'.  A 'group' is a set of
   // tabs whose opener's id and opener's navigation index match. The navigation
   // index is used in addition to the session id to detect navigations changes
   // within the same session.
-  for (NSUInteger i = startIndex + 1; i < [_tabs count]; ++i) {
-    Tab* tabToCheck = [_tabs objectAtIndex:i];
+  for (NSUInteger i = startIndex + 1; i < self.count; ++i) {
+    Tab* tabToCheck = [self webStateAtIndex:i];
     DCHECK([tabToCheck navigationManager]);
     CRWSessionController* sessionController =
         [tabToCheck navigationManager]->GetSessionController();
     if ([sessionController.openerId isEqualToString:parentID] &&
         sessionController.openerNavigationIndex == parentNavIndex) {
       match = tabToCheck;
     } else if (match) {
       break;
     }
   }
   return match;
 }
 
 - (Tab*)openerOfTab:(Tab*)tab {
   if (![tab navigationManager])
     return nil;
   NSString* opener = [tab navigationManager]->GetSessionController().openerId;
   if (!opener.length)  // Short-circuit if opener is empty.
     return nil;
-  for (Tab* iteratedTab in _tabs.get()) {
+  for (Tab* iteratedTab in self) {
     if ([[iteratedTab currentSessionID] isEqualToString:opener])
       return iteratedTab;
   }
   return nil;
 }
 
 - (Tab*)insertOrUpdateTabWithURL:(const GURL&)URL
                         referrer:(const web::Referrer&)referrer
                       transition:(ui::PageTransition)transition
                       windowName:(NSString*)windowName
@@ skipping 72 matching lines @@
   DCHECK_EQ(webState->GetBrowserState(), _browserState);
   base::scoped_nsobject<Tab> tab(
       [[Tab alloc] initWithWebState:std::move(webState) model:self]);
   [tab webController].webUsageEnabled = webUsageEnabled_;
   [self insertTab:tab atIndex:index];
   return tab;
 }
 
 - (void)insertTab:(Tab*)tab atIndex:(NSUInteger)index {
   DCHECK(tab);
-  DCHECK(index <= [_tabs count]);
+  DCHECK(index <= self.count);
   [tab fetchFavicon];
-  [_tabs insertObject:tab atIndex:index];
+  [self insertWebState:tab atIndex:index];
 
   [_observers tabModel:self didInsertTab:tab atIndex:index inForeground:NO];
   [_observers tabModelDidChangeTabCount:self];
 
   base::RecordAction(base::UserMetricsAction("MobileNewTabOpened"));
   // Persist the session due to a new tab being inserted. If this is a
   // background tab (will not become active), saving now will capture the
   // state properly. If it does eventually become active, another save will
   // be triggered to properly capture the end result.
   [self saveSessionImmediately:NO];
   ++_newTabCount;
 }
 
 - (void)moveTab:(Tab*)tab toIndex:(NSUInteger)toIndex {
   NSUInteger fromIndex = [self indexOfTab:tab];
   DCHECK_NE(NSNotFound, static_cast<NSInteger>(fromIndex));
   DCHECK_LT(toIndex, self.count);
   if (fromIndex == NSNotFound || toIndex >= self.count ||
       fromIndex == toIndex) {
     return;
   }
 
   base::scoped_nsobject<Tab> tabSaver([tab retain]);
-  [_tabs removeObject:tab];
-  [_tabs insertObject:tab atIndex:toIndex];
+  [self removeWebState:tab];
+  [self insertWebState:tab atIndex:toIndex];
 
   [_observers tabModel:self didMoveTab:tab fromIndex:fromIndex toIndex:toIndex];
 }
 
 - (void)replaceTab:(Tab*)oldTab
            withTab:(Tab*)newTab
     keepOldTabOpen:(BOOL)keepOldTabOpen {
   NSUInteger index = [self indexOfTab:oldTab];
   DCHECK_NE(NSNotFound, static_cast<NSInteger>(index));
 
   base::scoped_nsobject<Tab> tabSaver([oldTab retain]);
   [newTab fetchFavicon];
-  [_tabs replaceObjectAtIndex:index withObject:newTab];
+  [self replaceWebStateAtIndex:index withWebState:newTab];
   [newTab setParentTabModel:self];
 
   [_observers tabModel:self didReplaceTab:oldTab withTab:newTab atIndex:index];
 
   if (self.currentTab == oldTab)
     [self changeSelectedTabFrom:nil to:newTab persistState:NO];
 
   [oldTab setParentTabModel:nil];
   if (!keepOldTabOpen)
     [oldTab close];
 
   // Record a tab clobber, since swapping tabs bypasses the tab code that would
   // normally log clobbers.
   base::RecordAction(base::UserMetricsAction("MobileTabClobbered"));
 }
 
 - (void)closeTabAtIndex:(NSUInteger)index {
-  DCHECK(index < [_tabs count]);
-  [self closeTab:[_tabs objectAtIndex:index]];
+  DCHECK(index < self.count);
+  [self closeTab:[self webStateAtIndex:index]];
 }
 
 - (void)closeTab:(Tab*)tab {
   // Ensure the tab stays alive long enough for us to send out the
   // notice of its destruction to the delegate.
   [_observers tabModel:self willRemoveTab:tab];
   [tab close];  // Note it is not safe to access the tab after 'close'.
 }
 
 - (void)closeAllTabs {
   // If this changes, _closedTabCount metrics need to be adjusted.
   for (NSInteger i = self.count - 1; i >= 0; --i)
     [self closeTabAtIndex:i];
   [[NSNotificationCenter defaultCenter]
       postNotificationName:kTabModelAllTabsDidCloseNotification
                     object:self];
 }
 
 - (void)haltAllTabs {
-  for (Tab* tab in _tabs.get()) {
+  for (Tab* tab in self) {
     [tab terminateNetworkActivity];
   }
 }
 
 - (void)notifyTabChanged:(Tab*)tab {
   [_observers tabModel:self didChangeTab:tab];
 }
 
 - (void)addObserver:(id<TabModelObserver>)observer {
   [_observers addObserver:observer];
@@ skipping 16 matching lines @@
                               200, 50);
   UMA_HISTOGRAM_CUSTOM_COUNTS("Session.NewTabCounts", _newTabCount, 1, 200, 50);
 }
 
 - (void)notifyTabSnapshotChanged:(Tab*)tab withImage:(UIImage*)image {
   DCHECK([NSThread isMainThread]);
   [_observers tabModel:self didChangeTabSnapshot:tab withImage:image];
 }
 
 - (void)resetAllWebViews {
-  for (Tab* tab in _tabs.get()) {
+  for (Tab* tab in self) {
     [tab.webController reinitializeWebViewAndReload:(tab == _currentTab)];
   }
 }
 
 - (void)setWebUsageEnabled:(BOOL)webUsageEnabled {
   if (webUsageEnabled_ == webUsageEnabled)
     return;
   webUsageEnabled_ = webUsageEnabled;
-  for (Tab* tab in _tabs.get()) {
+  for (Tab* tab in self) {
     tab.webUsageEnabled = webUsageEnabled;
   }
 }
 
 - (void)setPrimary:(BOOL)primary {
   if (_tabUsageRecorder)
     _tabUsageRecorder->RecordPrimaryTabModelChange(primary, _currentTab);
 }
 
 - (NSSet*)currentlyReferencedExternalFiles {
   NSMutableSet* referencedFiles = [NSMutableSet set];
   if (!_browserState)
     return referencedFiles;
   // Check the currently open tabs for external files.
-  for (Tab* tab in _tabs.get()) {
+  for (Tab* tab in self) {
     if (UrlIsExternalFileReference(tab.url)) {
       NSString* fileName = base::SysUTF8ToNSString(tab.url.ExtractFileName());
       [referencedFiles addObject:fileName];
     }
   }
   // Do the same for the recently closed tabs.
   sessions::TabRestoreService* restoreService =
       IOSChromeTabRestoreServiceFactory::GetForBrowserState(_browserState);
   DCHECK(restoreService);
   for (const auto& entry : restoreService->entries()) {
@@ skipping 16 matching lines @@
   [[NSNotificationCenter defaultCenter] removeObserver:self];
   if (_browserState) {
     UnregisterTabModelFromChromeBrowserState(_browserState, self);
   }
   _browserState = nullptr;
 }
 
 // Called when a tab is closing, but before its CRWWebController is destroyed.
 // Equivalent to DetachTabContentsAt() in Chrome's TabStripModel.
 - (void)didCloseTab:(Tab*)closedTab {
-  NSUInteger closedTabIndex = [_tabs indexOfObject:closedTab];
+  NSUInteger closedTabIndex = [self indexOfWebState:closedTab];
   DCHECK(closedTab);
   DCHECK(closedTabIndex != NSNotFound);
   // Let the sessions::TabRestoreService know about that new tab.
   sessions::TabRestoreService* restoreService =
       _browserState
           ? IOSChromeTabRestoreServiceFactory::GetForBrowserState(_browserState)
           : nullptr;
   web::NavigationManagerImpl* navigationManager = [closedTab navigationManager];
   DCHECK(navigationManager);
   int itemCount = navigationManager->GetItemCount();
   if (restoreService && (![self isNTPTab:closedTab] || itemCount > 1)) {
     restoreService->CreateHistoricalTab(
         sessions::IOSLiveTab::GetForWebState(closedTab.webStateImpl),
         static_cast<int>(closedTabIndex));
   }
   // This needs to be called before the tab is removed from the list.
   Tab* newSelection =
       [_orderController determineNewSelectedTabFromRemovedTab:closedTab];
   base::scoped_nsobject<Tab> kungFuDeathGrip([closedTab retain]);
-  [_tabs removeObject:closedTab];
+  [self removeWebState:closedTab];
 
   // If closing the current tab, clear |_currentTab| before sending any
   // notification. This avoids various parts of the code getting confused
   // when the current tab isn't in the tab model.
   Tab* savedCurrentTab = _currentTab;
   if (closedTab == _currentTab)
     _currentTab.reset(nil);
 
   [_observers tabModel:self didRemoveTab:closedTab atIndex:closedTabIndex];
   [_observers tabModelDidChangeTabCount:self];
@@ skipping 30 matching lines @@
     if (previousURL.ReplaceComponents(replacements) ==
         currentURL.ReplaceComponents(replacements)) {
       return;
     }
   }
 
   int tabCount = static_cast<int>(self.count);
   UMA_HISTOGRAM_CUSTOM_COUNTS("Tabs.TabCountPerLoad", tabCount, 1, 200, 50);
 }
 
-#pragma mark - NSFastEnumeration
-
-- (NSUInteger)countByEnumeratingWithState:(NSFastEnumerationState*)state
-                                  objects:(id*)objects
-                                    count:(NSUInteger)count {
-  return [_tabs countByEnumeratingWithState:state objects:objects count:count];
-}
-
 #pragma mark - TabUsageRecorderDelegate
 
 - (NSUInteger)liveTabsCount {
   NSUInteger count = 0;
-  NSArray* tabs = _tabs.get();
-  for (Tab* tab in tabs) {
+  for (Tab* tab in self) {
     if ([tab.webController isViewAlive])
       count++;
   }
   return count;
 }
 
 #pragma mark - Private methods
 
 - (SessionWindowIOS*)windowForSavingSession {
   // Background tabs will already have their state preserved, but not the
   // fg tab. Do it now.
   [_currentTab recordStateInHistory];
 
   // Build the array of sessions. Copy the session objects as the saving will
   // be done on a separate thread.
   // TODO(crbug.com/661986): This could get expensive especially since this
   // window may never be saved (if another call comes in before the delay).
   SessionWindowIOS* window = [[[SessionWindowIOS alloc] init] autorelease];
-  for (Tab* tab in _tabs.get()) {
+  for (Tab* tab in self) {
     DCHECK(tab.webStateImpl);
     std::unique_ptr<web::WebStateImpl> webStateCopy(
         tab.webStateImpl->CopyForSessionWindow());
     [window addSession:std::move(webStateCopy)];
   }
   window.selectedIndex = [self indexOfTab:_currentTab];
   return window;
 }
 
 - (BOOL)isNTPTab:(Tab*)tab {
@@ skipping 144 matching lines @@
 - (void)applicationDidEnterBackground:(NSNotification*)notify {
   if (!_browserState)
     return;
   // Evict all the certificate policies except for the current entries of the
   // active sessions.
   scoped_refptr<web::CertificatePolicyCache> policy_cache =
       web::BrowserState::GetCertificatePolicyCache(_browserState);
   DCHECK(policy_cache);
   web::WebThread::PostTask(
       web::WebThread::IO, FROM_HERE,
-      base::Bind(&CleanCertificatePolicyCache, policy_cache, _tabs));
+      base::Bind(&CleanCertificatePolicyCache, policy_cache, self));
 
   if (_tabUsageRecorder)
     _tabUsageRecorder->AppDidEnterBackground();
 
   // Normally, the session is saved after some timer expires but since the app
   // is about to enter the background send YES to save the session immediately.
   [self saveSessionImmediately:YES];
 
   // Write out a grey version of the current website to disk.
   if (webUsageEnabled_ && _currentTab) {
@@ skipping 38 matching lines @@
   web::NavigationManager::WebLoadParams params(URL);
   params.referrer = referrer;
   params.transition_type = ui::PAGE_TRANSITION_TYPED;
   [[tab webController] loadWithParams:params];
   [tab webController].webUsageEnabled = webUsageEnabled_;
   [self insertTab:tab atIndex:index];
   return tab;
 }
 
 @end