Move the notion of current Tab from TabModel to WebStateList.

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>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #import "base/mac/scoped_nsobject.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/metrics/user_metrics.h"
 #include "base/metrics/user_metrics_action.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/task/cancelable_task_tracker.h"
 #include "components/sessions/core/serialized_navigation_entry.h"
 #include "components/sessions/core/session_id.h"
 #include "components/sessions/core/tab_restore_service.h"
 #include "components/sessions/ios/ios_live_tab.h"
 #include "ios/chrome/browser/browser_state/chrome_browser_state.h"
 #include "ios/chrome/browser/chrome_url_constants.h"
 #import "ios/chrome/browser/chrome_url_util.h"
 #import "ios/chrome/browser/metrics/tab_usage_recorder.h"
+#import "ios/chrome/browser/metrics/tab_usage_recorder_web_state_list_observer.h"
 #include "ios/chrome/browser/sessions/ios_chrome_tab_restore_service_factory.h"
 #import "ios/chrome/browser/sessions/session_service.h"
 #import "ios/chrome/browser/sessions/session_window.h"
 #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_order_controller.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_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"
@@ skipping 109 matching lines @@
 
   // 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;
 
   // WebStateListObserver bridges to react to modifications of the model (may
   // send notification, translate and forward events, update metrics, ...).
   std::vector<std::unique_ptr<WebStateListObserver>> _observerBridges;
 
-  // 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;
-  int _closedTabCount;
-  int _newTabCount;
+  WebStateListMetricsObserver* _webStateListMetricsObserver;
 
   // Backs up property with the same name.
   std::unique_ptr<TabUsageRecorder> _tabUsageRecorder;
   // Backs up property with the same name.
   const SessionID _sessionID;
   // Saves session's state.
   base::scoped_nsobject<SessionServiceIOS> _sessionService;
   // List of TabModelObservers.
   base::scoped_nsobject<TabModelObservers> _observers;
 
@@ skipping 16 matching lines @@
 // TabModelConstants::kTabPositionAutomatically if the caller doesn't have a
 // preference for the position of the tab.
 - (Tab*)insertTabWithLoadParams:
             (const web::NavigationManager::WebLoadParams&)params
                      windowName:(NSString*)windowName
                          opener:(Tab*)parentTab
                     openedByDOM:(BOOL)openedByDOM
                         atIndex:(NSUInteger)index
                    inBackground:(BOOL)inBackground;
 
-// Call to switch the selected tab. Broadcasts about the change in selection.
-// It's ok for |newTab| to be nil in case the last tab is going away. In that
-// case, the "tab deselected" notification gets sent, but no corresponding
-// "tab selected" notification is sent. |persist| indicates whether or not
-// the tab's state should be persisted in history upon switching.
-- (void)changeSelectedTabFrom:(Tab*)oldTab
-                           to:(Tab*)newTab
-                 persistState:(BOOL)persist;
-
-// Tells the snapshot cache the adjacent tab session ids.
-- (void)updateSnapshotCache:(Tab*)tab;
-
 // Helper method that posts a notification with the given name with |tab|
 // in the userInfo dictionary under the kTabModelTabKey.
 - (void)postNotificationName:(NSString*)notificationName withTab:(Tab*)tab;
 
 // Helper method to restore a saved session and control if the state should
 // be persisted or not. Used to implement the public -restoreSessionWindow:
 // method and restoring session in the initialiser.
 - (BOOL)restoreSessionWindow:(SessionWindowIOS*)window
                 persistState:(BOOL)persistState;
 
@@ skipping 22 matching lines @@
 
 #pragma mark - Overriden
 
 - (void)dealloc {
   DCHECK([_observers empty]);
   // 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());
   _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 {
-  return _currentTab.get();
+  web::WebState* webState = _webStateList.GetActiveWebState();
+  return webState ? LegacyTabHelper::GetTabForWebState(webState) : nil;
 }
 
 - (void)setCurrentTab:(Tab*)newTab {
-  DCHECK_NE([self indexOfTab:newTab], static_cast<NSUInteger>(NSNotFound));
-  if (_currentTab != newTab) {
-    base::RecordAction(base::UserMetricsAction("MobileTabSwitched"));
-    [self updateSnapshotCache:newTab];
-  }
-  if (_tabUsageRecorder) {
-    _tabUsageRecorder->RecordTabSwitched(_currentTab, newTab);
-  }
-  [self changeSelectedTabFrom:_currentTab to:newTab persistState:YES];
+  int indexOfTab = _webStateList.GetIndexOfWebState(newTab.webState);
+  DCHECK_NE(indexOfTab, WebStateList::kInvalidIndex);
+  _webStateList.ActivateWebStateAt(indexOfTab);
 }
 
 - (TabModelSyncedWindowDelegate*)syncedWindowDelegate {
   return _syncedWindowDelegate.get();
 }
 
 - (TabUsageRecorder*)tabUsageRecorder {
   return _tabUsageRecorder.get();
 }
 
@@ skipping 31 matching lines @@
       // Set up the usage recorder before tabs are created.
       _tabUsageRecorder = base::MakeUnique<TabUsageRecorder>(self);
     }
     _syncedWindowDelegate =
         base::MakeUnique<TabModelSyncedWindowDelegate>(self);
 
     // There must be a valid session service defined to consume session windows.
     DCHECK(service);
     _sessionService.reset([service retain]);
 
+    _observerBridges.push_back(
+        base::MakeUnique<SnapshotCacheWebStateListObserver>(
+            [SnapshotCache sharedInstance]));
+    if (_tabUsageRecorder) {
+      _observerBridges.push_back(
+          base::MakeUnique<TabUsageRecorderWebStateListObserver>(
+              _tabUsageRecorder.get()));
+    }
     _observerBridges.push_back(base::MakeUnique<TabParentingObserver>());
     _observerBridges.push_back(base::MakeUnique<WebStateListObserverBridge>(
+        [[TabModelSelectedTabObserver alloc] initWithTabModel:self]));
+    _observerBridges.push_back(base::MakeUnique<WebStateListObserverBridge>(
         [[TabModelObserversBridge alloc] initWithTabModel:self
                                         tabModelObservers:_observers.get()]));
-    _observerBridges.push_back(base::MakeUnique<WebStateListMetricsObserver>());
+
+    auto webStateListMetricsObserver =
+        base::MakeUnique<WebStateListMetricsObserver>();
+    _webStateListMetricsObserver = webStateListMetricsObserver.get();
+    _observerBridges.push_back(std::move(webStateListMetricsObserver));
 
     for (const auto& observerBridge : _observerBridges)
       _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];
     }
 
-    _orderController.reset(
-        [[TabModelOrderController alloc] initWithTabModel:self]);
-
     // Register for resign active notification.
     [[NSNotificationCenter defaultCenter]
         addObserver:self
            selector:@selector(willResignActive:)
                name:UIApplicationWillResignActiveNotification
              object:nil];
     // Register for background notification.
     [[NSNotificationCenter defaultCenter]
         addObserver:self
            selector:@selector(applicationDidEnterBackground:)
@@ skipping 17 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 ((!_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)));
@@ skipping 158 matching lines @@
     const int insertion_index = static_cast<int>(index);
     _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];
-
-  ++_newTabCount;
 }
 
 - (void)insertTab:(Tab*)tab atIndex:(NSUInteger)index opener:(Tab*)parentTab {
   DCHECK(tab);
   DCHECK(![_tabRetainer containsObject:tab]);
   DCHECK_LE(index, static_cast<NSUInteger>(INT_MAX));
 
   [self insertTab:tab
           atIndex:index
            opener:parentTab
@@ skipping 24 matching lines @@
   DCHECK_GE(index, 0);
 
   base::scoped_nsobject<Tab> tabSaver([oldTab retain]);
   [_tabRetainer removeObject:oldTab];
   [_tabRetainer addObject:newTab];
   [newTab setParentTabModel:self];
 
   _webStateList.ReplaceWebStateAt(index, newTab.webState,
                                   GetOpenerForTab(self, newTab).webState);
 
-  if (self.currentTab == oldTab)
-    [self changeSelectedTabFrom:nil to:newTab persistState:NO];
-
   [oldTab setParentTabModel:nil];
   [oldTab close];
 }
 
 - (void)closeTabAtIndex:(NSUInteger)index {
   DCHECK(index < self.count);
   [self closeTab:[self tabAtIndex: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 self) {
     [tab terminateNetworkActivity];
   }
 }
 
 - (void)notifyTabChanged:(Tab*)tab {
   [_observers tabModel:self didChangeTab:tab];
 }
 
 - (void)addObserver:(id<TabModelObserver>)observer {
   [_observers addObserver:observer];
 }
 
 - (void)removeObserver:(id<TabModelObserver>)observer {
   [_observers removeObserver:observer];
 }
 
 - (void)resetSessionMetrics {
-  _closedTabCount = 0;
-  _openedTabCount = 0;
-  _newTabCount = 0;
+  if (_webStateListMetricsObserver)
+    _webStateListMetricsObserver->ResetSessionMetrics();
 }
 
 - (void)recordSessionMetrics {
-  UMA_HISTOGRAM_CUSTOM_COUNTS("Session.ClosedTabCounts", _closedTabCount, 1,
-                              200, 50);
-  UMA_HISTOGRAM_CUSTOM_COUNTS("Session.OpenedTabCounts", _openedTabCount, 1,
-                              200, 50);
-  UMA_HISTOGRAM_CUSTOM_COUNTS("Session.NewTabCounts", _newTabCount, 1, 200, 50);
+  if (_webStateListMetricsObserver)
+    _webStateListMetricsObserver->RecordSessionMetrics();
 }
 
 - (void)notifyTabSnapshotChanged:(Tab*)tab withImage:(UIImage*)image {
   DCHECK([NSThread isMainThread]);
   [_observers tabModel:self didChangeTabSnapshot:tab withImage:image];
 }
 
 - (void)resetAllWebViews {
   for (Tab* tab in self) {
-    [tab.webController reinitializeWebViewAndReload:(tab == _currentTab)];
+    [tab.webController reinitializeWebViewAndReload:(tab == self.currentTab)];
   }
 }
 
 - (void)setWebUsageEnabled:(BOOL)webUsageEnabled {
   if (webUsageEnabled_ == webUsageEnabled)
     return;
   webUsageEnabled_ = webUsageEnabled;
   for (Tab* tab in self) {
     tab.webUsageEnabled = webUsageEnabled;
   }
 }
 
 - (void)setPrimary:(BOOL)primary {
   if (_tabUsageRecorder)
-    _tabUsageRecorder->RecordPrimaryTabModelChange(primary, _currentTab);
+    _tabUsageRecorder->RecordPrimaryTabModelChange(primary, self.currentTab);
 }
 
 - (NSSet*)currentlyReferencedExternalFiles {
   NSMutableSet* referencedFiles = [NSMutableSet set];
   if (!_browserState)
     return referencedFiles;
   // Check the currently open tabs for external files.
   for (Tab* tab in self) {
     if (UrlIsExternalFileReference(tab.url)) {
       NSString* fileName = base::SysUTF8ToNSString(tab.url.ExtractFileName());
@@ skipping 43 matching lines @@
           ? 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.webState),
         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]);
 
-  // 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);
+  // If a non-current Tab is closed, save the session (it will be saved by
+  // TabModelObserversBridge if the currentTab has been closed).
+  BOOL needToSaveSession = (closedTab != self.currentTab);
 
   DCHECK([_tabRetainer containsObject:closedTab]);
   [_tabRetainer removeObject:closedTab];
 
   _webStateList.DetachWebStateAt(closedTabIndex);
 
-  // Current tab has closed, update the selected tab and swap in its
-  // contents. There is nothing to do if a non-selected tab is closed as
-  // the selection isn't index-based, therefore it hasn't changed.
-  // -changeSelectedTabFrom: will persist the state change, so only do it
-  // if the selection isn't changing.
-  if (closedTab == savedCurrentTab) {
-    [self changeSelectedTabFrom:closedTab to:newSelection persistState:NO];
-  } else {
+  if (needToSaveSession)
     [self saveSessionImmediately:NO];
-  }
-  ++_closedTabCount;
 }
 
 - (void)navigationCommittedInTab:(Tab*)tab {
   if (self.offTheRecord)
     return;
   if (![tab navigationManager])
     return;
 
   // See if the navigation was within a page; if so ignore it.
   web::NavigationItem* previousItem =
@@ skipping 33 matching lines @@
       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];
+  [self.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 self) {
     web::WebState* webState = tab.webState;
     DCHECK(webState);
     [window addSerializedSessionStorage:webState->BuildSessionStorage()];
   }
-  window.selectedIndex = [self indexOfTab:_currentTab];
+  window.selectedIndex = [self indexOfTab:self.currentTab];
   return window;
 }
 
 - (BOOL)isNTPTab:(Tab*)tab {
   std::string host = tab.url.host();
   return host == kChromeUINewTabHost || host == kChromeUIBookmarksHost;
 }
 
 - (Tab*)insertTabWithLoadParams:
             (const web::NavigationManager::WebLoadParams&)params
@@ skipping 31 matching lines @@
       postNotificationName:kTabModelNewTabWillOpenNotification
                     object:self
                   userInfo:userInfo];
 
   if (!inBackground)
     [self setCurrentTab:tab];
 
   return tab;
 }
 
-- (void)changeSelectedTabFrom:(Tab*)oldTab
-                           to:(Tab*)newTab
-                 persistState:(BOOL)persist {
-  if (oldTab) {
-    // Save state, such as scroll position, before switching tabs.
-    if (oldTab != newTab && persist)
-      [oldTab recordStateInHistory];
-    [self postNotificationName:kTabModelTabDeselectedNotification
-                       withTab:oldTab];
-  }
-
-  // No Tab to select (e.g. the last Tab has been closed).
-  if ([self indexOfTab:newTab] == NSNotFound)
-    return;
-
-  _currentTab.reset(newTab);
-  if (newTab) {
-    [_observers tabModel:self
-        didChangeActiveTab:newTab
-               previousTab:oldTab
-                   atIndex:[self indexOfTab:newTab]];
-    [newTab updateLastVisitedTimestamp];
-    ++_openedTabCount;
-  }
-  BOOL loadingFinished = [newTab.webController loadPhase] == web::PAGE_LOADED;
-  if (loadingFinished) {
-    // Persist the session state.
-    [self saveSessionImmediately:NO];
-  }
-}
-
-- (void)updateSnapshotCache:(Tab*)tab {
-  NSMutableSet* set = [NSMutableSet set];
-  NSUInteger index = [self indexOfTab:tab];
-  if (index > 0) {
-    Tab* previousTab = [self tabAtIndex:(index - 1)];
-    [set addObject:previousTab.tabId];
-  }
-  if (index < self.count - 1) {
-    Tab* nextTab = [self tabAtIndex:(index + 1)];
-    [set addObject:nextTab.tabId];
-  }
-  [SnapshotCache sharedInstance].pinnedIDs = set;
-}
-
 - (void)postNotificationName:(NSString*)notificationName withTab:(Tab*)tab {
   // A scoped_nsobject is used rather than an NSDictionary with static
   // initializer dictionaryWithObject, because that approach adds the dictionary
   // to the autorelease pool, which in turn holds Tab alive longer than
   // necessary.
   base::scoped_nsobject<NSDictionary> userInfo(
       [[NSDictionary alloc] initWithObjectsAndKeys:tab, kTabModelTabKey, nil]);
   [[NSNotificationCenter defaultCenter] postNotificationName:notificationName
                                                       object:self
                                                     userInfo:userInfo];
@@ skipping 48 matching lines @@
       DCHECK(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]);
-    [self changeSelectedTabFrom:_currentTab
-                             to:[self tabAtIndex:selectedIndex]
-                   persistState:persistState];
+
+    if (persistState && self.currentTab)
+      [self.currentTab recordStateInHistory];
+    _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);
       [restoredTabs addObject:LegacyTabHelper::GetTabForWebState(webState)];
     }
-    _tabUsageRecorder->InitialRestoredTabs(_currentTab, restoredTabs);
+    _tabUsageRecorder->InitialRestoredTabs(self.currentTab, restoredTabs);
   }
   return closedNTPTab;
 }
 
 #pragma mark - Notification Handlers
 
 // Called when UIApplicationWillResignActiveNotification is received.
 - (void)willResignActive:(NSNotification*)notify {
-  if (webUsageEnabled_ && _currentTab) {
+  if (webUsageEnabled_ && self.currentTab) {
     [[SnapshotCache sharedInstance]
-        willBeSavedGreyWhenBackgrounding:_currentTab.get().tabId];
+        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);
 
   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) {
+  if (webUsageEnabled_ && self.currentTab) {
     [[SnapshotCache sharedInstance]
-        saveGreyInBackgroundForSessionID:_currentTab.get().tabId];
+        saveGreyInBackgroundForSessionID:self.currentTab.tabId];
   }
 }
 
 // Called when UIApplicationWillEnterForegroundNotification is received.
 - (void)applicationWillEnterForeground:(NSNotification*)notify {
   if (_tabUsageRecorder) {
     _tabUsageRecorder->AppWillEnterForeground();
   }
 }
 
@@ skipping 26 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 opener:parentTab];
   return tab;
 }
 
 @end