[ios] Add a delegate to WebStateList class.

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 <cstdint>
 #include <utility>
 #include <vector>
 
@@ skipping 20 matching lines @@
 #import "ios/chrome/browser/snapshots/snapshot_cache.h"
 #import "ios/chrome/browser/snapshots/snapshot_cache_web_state_list_observer.h"
 #include "ios/chrome/browser/tab_parenting_global_observer.h"
 #import "ios/chrome/browser/tabs/legacy_tab_helper.h"
 #import "ios/chrome/browser/tabs/tab.h"
 #import "ios/chrome/browser/tabs/tab_model_list.h"
 #import "ios/chrome/browser/tabs/tab_model_observers.h"
 #import "ios/chrome/browser/tabs/tab_model_observers_bridge.h"
 #import "ios/chrome/browser/tabs/tab_model_selected_tab_observer.h"
 #import "ios/chrome/browser/tabs/tab_model_synced_window_delegate.h"
+#import "ios/chrome/browser/tabs/tab_model_web_state_list_delegate.h"
 #import "ios/chrome/browser/tabs/tab_parenting_observer.h"
 #import "ios/chrome/browser/xcallback_parameters.h"
 #import "ios/shared/chrome/browser/tabs/web_state_list.h"
 #import "ios/shared/chrome/browser/tabs/web_state_list_fast_enumeration_helper.h"
 #import "ios/shared/chrome/browser/tabs/web_state_list_metrics_observer.h"
 #import "ios/shared/chrome/browser/tabs/web_state_list_observer.h"
 #import "ios/web/navigation/crw_session_certificate_policy_manager.h"
 #import "ios/web/navigation/crw_session_controller.h"
 #include "ios/web/public/browser_state.h"
 #include "ios/web/public/certificate_policy_cache.h"
@@ skipping 89 matching lines @@
 
 @implementation TabModelWebStateProxyFactory
 
 - (id)proxyForWebState:(web::WebState*)webState {
   return LegacyTabHelper::GetTabForWebState(webState);
 }
 
 @end
 
 @interface TabModel ()<TabUsageRecorderDelegate> {
+  // Delegate for the WebStateList.
+  std::unique_ptr<WebStateListDelegate> _webStateListDelegate;
+
   // Underlying shared model implementation.
-  WebStateList _webStateList;
+  std::unique_ptr<WebStateList> _webStateList;
 
   // Helper providing NSFastEnumeration implementation over the WebStateList.
   base::scoped_nsobject<WebStateListFastEnumerationHelper>
       _fastEnumerationHelper;
 
   // Used to keep the Tabs alive while the corresponding WebStates are stored
   // in the WebStateList (as Tabs currently own their WebState). Remove once
   // WebState owns the associated Tab.
   base::scoped_nsobject<NSMutableSet<Tab*>> _tabRetainer;
 
@@ skipping 66 matching lines @@
   // browserStateDestroyed should always have been called before destruction.
   DCHECK(!_browserState);
 
   [[NSNotificationCenter defaultCenter] removeObserver:self];
 
   // Clear weak pointer to WebStateListMetricsObserver before destroying it.
   _webStateListMetricsObserver = nullptr;
 
   // Unregister all listeners before closing all the tabs.
   for (const auto& observerBridge : _observerBridges)
-    _webStateList.RemoveObserver(observerBridge.get());
+    _webStateList->RemoveObserver(observerBridge.get());
   _observerBridges.clear();
 
   // Make sure the tabs do clean after themselves. It is important for
   // removeObserver: to be called first otherwise a lot of unecessary work will
   // happen on -closeAllTabs.
   [self closeAllTabs];
 
   _clearPoliciesTaskTracker.TryCancelAll();
 
   [super dealloc];
 }
 
 #pragma mark - Public methods
 
 - (Tab*)currentTab {
-  web::WebState* webState = _webStateList.GetActiveWebState();
+  web::WebState* webState = _webStateList->GetActiveWebState();
   return webState ? LegacyTabHelper::GetTabForWebState(webState) : nil;
 }
 
 - (void)setCurrentTab:(Tab*)newTab {
-  int indexOfTab = _webStateList.GetIndexOfWebState(newTab.webState);
+  int indexOfTab = _webStateList->GetIndexOfWebState(newTab.webState);
   DCHECK_NE(indexOfTab, WebStateList::kInvalidIndex);
-  _webStateList.ActivateWebStateAt(indexOfTab);
+  _webStateList->ActivateWebStateAt(indexOfTab);
 }
 
 - (TabModelSyncedWindowDelegate*)syncedWindowDelegate {
   return _syncedWindowDelegate.get();
 }
 
 - (TabUsageRecorder*)tabUsageRecorder {
   return _tabUsageRecorder.get();
 }
 
 - (BOOL)isOffTheRecord {
   return _browserState && _browserState->IsOffTheRecord();
 }
 
 - (BOOL)isEmpty {
-  return _webStateList.empty();
+  return _webStateList->empty();
 }
 
 - (NSUInteger)count {
-  DCHECK_GE(_webStateList.count(), 0);
-  return static_cast<NSUInteger>(_webStateList.count());
+  DCHECK_GE(_webStateList->count(), 0);
+  return static_cast<NSUInteger>(_webStateList->count());
 }
 
 - (instancetype)initWithSessionWindow:(SessionWindowIOS*)window
                        sessionService:(SessionServiceIOS*)service
                          browserState:(ios::ChromeBrowserState*)browserState {
   if ((self = [super init])) {
     _tabRetainer.reset([[NSMutableSet alloc] init]);
     _observers.reset([[TabModelObservers observers] retain]);
 
+    _webStateListDelegate =
+        base::MakeUnique<TabModelWebStateListDelegate>(self);
+    _webStateList = base::MakeUnique<WebStateList>(
+        _webStateListDelegate.get(), WebStateList::WebStateBorrowed);
+
     _fastEnumerationHelper.reset([[WebStateListFastEnumerationHelper alloc]
-        initWithWebStateList:&_webStateList
+        initWithWebStateList:_webStateList.get()
                 proxyFactory:[[TabModelWebStateProxyFactory alloc] init]]);
 
     _browserState = browserState;
     DCHECK(_browserState);
 
     // 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.
@@ skipping 20 matching lines @@
     _observerBridges.push_back(base::MakeUnique<WebStateListObserverBridge>(
         [[TabModelObserversBridge alloc] initWithTabModel:self
                                         tabModelObservers:_observers.get()]));
 
     auto webStateListMetricsObserver =
         base::MakeUnique<WebStateListMetricsObserver>();
     _webStateListMetricsObserver = webStateListMetricsObserver.get();
     _observerBridges.push_back(std::move(webStateListMetricsObserver));
 
     for (const auto& observerBridge : _observerBridges)
-      _webStateList.AddObserver(observerBridge.get());
+      _webStateList->AddObserver(observerBridge.get());
 
     if (window) {
       DCHECK([_observers empty]);
       // Restore the session and reset the session metrics (as the event have
       // not been generated by the user but by a cold start cycle).
       [self restoreSessionWindow:window persistState:NO];
       [self resetSessionMetrics];
     }
 
     // Register for resign active notification.
@@ skipping 26 matching lines @@
   return nil;
 }
 
 - (BOOL)restoreSessionWindow:(SessionWindowIOS*)window {
   return [self restoreSessionWindow:window persistState:YES];
 }
 
 - (void)saveSessionImmediately:(BOOL)immediately {
   // Do nothing if there are tabs in the model but no selected tab. This is
   // a transitional state.
-  if ((!self.currentTab && _webStateList.count()) || !_browserState)
+  if ((!self.currentTab && _webStateList->count()) || !_browserState)
     return;
   [_sessionService saveWindow:self.windowForSavingSession
               forBrowserState:_browserState
                   immediately:immediately];
 }
 
 - (Tab*)tabAtIndex:(NSUInteger)index {
   DCHECK_LE(index, static_cast<NSUInteger>(INT_MAX));
   return LegacyTabHelper::GetTabForWebState(
-      _webStateList.GetWebStateAt(static_cast<int>(index)));
+      _webStateList->GetWebStateAt(static_cast<int>(index)));
 }
 
 - (NSUInteger)indexOfTab:(Tab*)tab {
-  int index = _webStateList.GetIndexOfWebState(tab.webState);
+  int index = _webStateList->GetIndexOfWebState(tab.webState);
   if (index == WebStateList::kInvalidIndex)
     return NSNotFound;
 
   DCHECK_GE(index, 0);
   return static_cast<NSUInteger>(index);
 }
 
 - (Tab*)nextTabWithOpener:(Tab*)tab afterTab:(Tab*)afterTab {
   int startIndex = WebStateList::kInvalidIndex;
   if (afterTab)
-    startIndex = _webStateList.GetIndexOfWebState(afterTab.webState);
+    startIndex = _webStateList->GetIndexOfWebState(afterTab.webState);
 
   if (startIndex == WebStateList::kInvalidIndex)
-    startIndex = _webStateList.GetIndexOfWebState(tab.webState);
+    startIndex = _webStateList->GetIndexOfWebState(tab.webState);
 
-  const int index = _webStateList.GetIndexOfNextWebStateOpenedBy(
+  const int index = _webStateList->GetIndexOfNextWebStateOpenedBy(
       tab.webState, startIndex, false);
   if (index == WebStateList::kInvalidIndex)
     return nil;
 
   DCHECK_GE(index, 0);
   return [self tabAtIndex:static_cast<NSUInteger>(index)];
 }
 
 - (Tab*)lastTabWithOpener:(Tab*)tab {
-  int startIndex = _webStateList.GetIndexOfWebState(tab.webState);
+  int startIndex = _webStateList->GetIndexOfWebState(tab.webState);
   if (startIndex == WebStateList::kInvalidIndex)
     return nil;
 
-  const int index = _webStateList.GetIndexOfLastWebStateOpenedBy(
+  const int index = _webStateList->GetIndexOfLastWebStateOpenedBy(
       tab.webState, startIndex, true);
   if (index == WebStateList::kInvalidIndex)
     return nil;
 
   DCHECK_GE(index, 0);
   return [self tabAtIndex:static_cast<NSUInteger>(index)];
 }
 
 - (Tab*)openerOfTab:(Tab*)tab {
-  int index = _webStateList.GetIndexOfWebState(tab.webState);
+  int index = _webStateList->GetIndexOfWebState(tab.webState);
   if (index == WebStateList::kInvalidIndex)
     return nil;
 
-  web::WebState* opener = _webStateList.GetOpenerOfWebStateAt(index);
+  web::WebState* opener = _webStateList->GetOpenerOfWebStateAt(index);
   return opener ? LegacyTabHelper::GetTabForWebState(opener) : nil;
 }
 
 - (Tab*)insertTabWithURL:(const GURL&)URL
                 referrer:(const web::Referrer&)referrer
               transition:(ui::PageTransition)transition
                   opener:(Tab*)parentTab
              openedByDOM:(BOOL)openedByDOM
                  atIndex:(NSUInteger)index
             inBackground:(BOOL)inBackground {
@@ skipping 60 matching lines @@
 
 - (void)insertTab:(Tab*)tab
           atIndex:(NSUInteger)index
            opener:(Tab*)parentTab
        transition:(ui::PageTransition)transition {
   DCHECK(tab);
   DCHECK(![_tabRetainer containsObject:tab]);
 
   [_tabRetainer addObject:tab];
   if (index == TabModelConstants::kTabPositionAutomatically) {
-    _webStateList.AppendWebState(transition, tab.webState, parentTab.webState);
+    _webStateList->AppendWebState(transition, tab.webState, parentTab.webState);
   } else {
     DCHECK_LE(index, static_cast<NSUInteger>(INT_MAX));
     const int insertion_index = static_cast<int>(index);
-    _webStateList.InsertWebState(insertion_index, tab.webState,
-                                 parentTab.webState);
+    _webStateList->InsertWebState(insertion_index, tab.webState,
+                                  parentTab.webState);
   }
 
   // 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];
 }
 
 - (void)insertTab:(Tab*)tab atIndex:(NSUInteger)index opener:(Tab*)parentTab {
@@ skipping 11 matching lines @@
   DCHECK(tab);
   DCHECK(![_tabRetainer containsObject:tab]);
   DCHECK_LE(index, static_cast<NSUInteger>(INT_MAX));
 
   [self insertTab:tab atIndex:index opener:GetOpenerForTab(self, tab)];
 }
 
 - (void)moveTab:(Tab*)tab toIndex:(NSUInteger)toIndex {
   DCHECK([_tabRetainer containsObject:tab]);
   DCHECK_LE(toIndex, static_cast<NSUInteger>(INT_MAX));
-  int fromIndex = _webStateList.GetIndexOfWebState(tab.webState);
-  _webStateList.MoveWebStateAt(fromIndex, static_cast<int>(toIndex));
+  int fromIndex = _webStateList->GetIndexOfWebState(tab.webState);
+  _webStateList->MoveWebStateAt(fromIndex, static_cast<int>(toIndex));
 }
 
 - (void)replaceTab:(Tab*)oldTab withTab:(Tab*)newTab {
   DCHECK([_tabRetainer containsObject:oldTab]);
   DCHECK(![_tabRetainer containsObject:newTab]);
 
-  int index = _webStateList.GetIndexOfWebState(oldTab.webState);
+  int index = _webStateList->GetIndexOfWebState(oldTab.webState);
   DCHECK_NE(index, WebStateList::kInvalidIndex);
   DCHECK_GE(index, 0);
 
   base::scoped_nsobject<Tab> tabSaver([oldTab retain]);
   [_tabRetainer removeObject:oldTab];
   [_tabRetainer addObject:newTab];
   [newTab setParentTabModel:self];
 
   // The WebState is owned by the associated Tab, so it is safe to ignore
   // the result and won't cause a memory leak. Once the ownership is moved
   // to WebStateList, this function will return a std::unique_ptr<> and the
   // object destroyed as expected, so it will fine to ignore the result then
   // too. See http://crbug.com/546222 for progress of changing the ownership
   // of the WebStates.
-  ignore_result(_webStateList.ReplaceWebStateAt(
+  ignore_result(_webStateList->ReplaceWebStateAt(
       index, newTab.webState, GetOpenerForTab(self, newTab).webState));
 
   [oldTab setParentTabModel:nil];
   [oldTab close];
 }
 
 - (void)closeTabAtIndex:(NSUInteger)index {
   DCHECK(index < self.count);
   [self closeTab:[self tabAtIndex:index]];
 }
@@ skipping 103 matching lines @@
     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 {
   DCHECK(closedTab);
   DCHECK([_tabRetainer containsObject:closedTab]);
-  int closedTabIndex = _webStateList.GetIndexOfWebState(closedTab.webState);
+  int closedTabIndex = _webStateList->GetIndexOfWebState(closedTab.webState);
   DCHECK_NE(closedTabIndex, WebStateList::kInvalidIndex);
   DCHECK_GE(closedTabIndex, 0);
 
   // Let the sessions::TabRestoreService know about that new tab.
   sessions::TabRestoreService* restoreService =
       _browserState
           ? IOSChromeTabRestoreServiceFactory::GetForBrowserState(_browserState)
           : nullptr;
   web::NavigationManager* navigationManager = [closedTab navigationManager];
   DCHECK(navigationManager);
@@ skipping 12 matching lines @@
 
   DCHECK([_tabRetainer containsObject:closedTab]);
   [_tabRetainer removeObject:closedTab];
 
   // The WebState is owned by the associated Tab, so it is safe to ignore
   // the result and won't cause a memory leak. Once the ownership is moved
   // to WebStateList, this function will return a std::unique_ptr<> and the
   // object destroyed as expected, so it will fine to ignore the result then
   // too. See http://crbug.com/546222 for progress of changing the ownership
   // of the WebStates.
-  ignore_result(_webStateList.DetachWebStateAt(closedTabIndex));
+  ignore_result(_webStateList->DetachWebStateAt(closedTabIndex));
 
   if (needToSaveSession)
     [self saveSessionImmediately:NO];
 }
 
 - (void)navigationCommittedInTab:(Tab*)tab
                     previousItem:(web::NavigationItem*)previousItem {
   if (self.offTheRecord)
     return;
   if (![tab navigationManager])
@@ skipping 77 matching lines @@
 
 - (BOOL)restoreSessionWindow:(SessionWindowIOS*)window
                 persistState:(BOOL)persistState {
   DCHECK(_browserState);
   DCHECK(window);
 
   NSArray* sessions = window.sessions;
   if (!sessions.count)
     return NO;
 
-  int oldCount = _webStateList.count();
+  int oldCount = _webStateList->count();
   DCHECK_GE(oldCount, 0);
 
   web::WebState::CreateParams params(_browserState);
   scoped_refptr<web::CertificatePolicyCache> policyCache =
       web::BrowserState::GetCertificatePolicyCache(_browserState);
 
   base::scoped_nsobject<NSMutableArray<Tab*>> restoredTabs(
       [[NSMutableArray alloc] initWithCapacity:sessions.count]);
 
   // Recreate all the restored Tabs and add them to the WebStateList without
   // any opener-opened relationship (as the n-th restored Tab opener may be
   // at an index larger than n). Then in a second pass fix the openers.
   for (CRWSessionStorage* session in sessions) {
     std::unique_ptr<web::WebState> webState =
         web::WebState::Create(params, session);
     base::scoped_nsobject<Tab> tab(
         [[Tab alloc] initWithWebState:std::move(webState) model:self]);
     [tab webController].webUsageEnabled = webUsageEnabled_;
     [tab webController].usePlaceholderOverlay = YES;
 
     // Restore the CertificatePolicyCache (note that webState is invalid after
     // passing it via move semantic to -initWithWebState:model:).
     UpdateCertificatePolicyCacheFromWebState(policyCache, [tab webState]);
     [self insertTab:tab atIndex:self.count opener:nil];
     [restoredTabs addObject:tab.get()];
   }
 
   DCHECK_EQ(sessions.count, [restoredTabs count]);
-  DCHECK_GT(_webStateList.count(), oldCount);
+  DCHECK_GT(_webStateList->count(), oldCount);
 
   // Fix openers now that all Tabs have been restored. Only look for an opener
   // Tab in the newly restored Tabs and not in the already open Tabs.
-  for (int index = oldCount; index < _webStateList.count(); ++index) {
+  for (int index = oldCount; index < _webStateList->count(); ++index) {
     DCHECK_GE(index, oldCount);
     NSUInteger tabIndex = static_cast<NSUInteger>(index - oldCount);
     Tab* tab = [restoredTabs objectAtIndex:tabIndex];
     Tab* opener = GetOpenerForTab(restoredTabs.get(), tab);
     if (opener) {
       DCHECK(opener.webState);
-      _webStateList.SetOpenerOfWebStateAt(index, opener.webState);
+      _webStateList->SetOpenerOfWebStateAt(index, opener.webState);
     }
   }
 
   // Update the selected tab if there was a selected Tab in the saved session.
   if (window.selectedIndex != NSNotFound) {
     NSUInteger selectedIndex = window.selectedIndex + oldCount;
     DCHECK_LT(selectedIndex, self.count);
     DCHECK([self tabAtIndex:selectedIndex]);
 
     if (persistState && self.currentTab)
       [self.currentTab recordStateInHistory];
-    _webStateList.ActivateWebStateAt(static_cast<int>(selectedIndex));
+    _webStateList->ActivateWebStateAt(static_cast<int>(selectedIndex));
   }
 
   // If there was only one tab and it was the new tab page, clobber it.
   BOOL closedNTPTab = NO;
   if (oldCount == 1) {
     Tab* tab = [self tabAtIndex:0];
     if (tab.url == GURL(kChromeUINewTabURL)) {
       [self closeTab:tab];
       closedNTPTab = YES;
       oldCount = 0;
     }
   }
   if (_tabUsageRecorder) {
     NSMutableArray<Tab*>* restoredTabs =
-        [NSMutableArray arrayWithCapacity:_webStateList.count() - oldCount];
-    for (int index = oldCount; index < _webStateList.count(); ++index) {
-      web::WebState* webState = _webStateList.GetWebStateAt(index);
+        [NSMutableArray arrayWithCapacity:_webStateList->count() - oldCount];
+    for (int index = oldCount; index < _webStateList->count(); ++index) {
+      web::WebState* webState = _webStateList->GetWebStateAt(index);
       [restoredTabs addObject:LegacyTabHelper::GetTabForWebState(webState)];
     }
     _tabUsageRecorder->InitialRestoredTabs(self.currentTab, restoredTabs);
   }
   return closedNTPTab;
 }
 
 #pragma mark - Notification Handlers
 
 // Called when UIApplicationWillResignActiveNotification is received.
 - (void)willResignActive:(NSNotification*)notify {
   if (webUsageEnabled_ && self.currentTab) {
     [[SnapshotCache sharedInstance]
         willBeSavedGreyWhenBackgrounding:self.currentTab.tabId];
   }
 }
 
 // Called when UIApplicationDidEnterBackgroundNotification is received.
 - (void)applicationDidEnterBackground:(NSNotification*)notify {
   if (!_browserState)
     return;
 
   // Evict all the certificate policies except for the current entries of the
   // active sessions.
   CleanCertificatePolicyCache(
       &_clearPoliciesTaskTracker,
       web::WebThread::GetTaskRunnerForThread(web::WebThread::IO),
       web::BrowserState::GetCertificatePolicyCache(_browserState),
-      &_webStateList);
+      _webStateList.get());
 
   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_ && self.currentTab) {
     [[SnapshotCache sharedInstance]
         saveGreyInBackgroundForSessionID:self.currentTab.tabId];
   }
 }
 
 // Called when UIApplicationWillEnterForegroundNotification is received.
 - (void)applicationWillEnterForeground:(NSNotification*)notify {
   if (_tabUsageRecorder) {
     _tabUsageRecorder->AppWillEnterForeground();
   }
 }
 
 @end