[ios] Expose TabModel underlying 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>
 
@@ skipping 145 matching lines @@
 
   // 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;
 
-  // 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;
+  // WebStateListObservers reacting to modifications of the model (may send
+  // notification, translate and forward events, update metrics, ...).
+  std::vector<std::unique_ptr<WebStateListObserver>> _webStateListObservers;
 
   // The delegate for sync.
   std::unique_ptr<TabModelSyncedWindowDelegate> _syncedWindowDelegate;
 
   // Counters for metrics.
   WebStateListMetricsObserver* _webStateListMetricsObserver;
 
   // Backs up property with the same name.
   std::unique_ptr<TabUsageRecorder> _tabUsageRecorder;
   // Backs up property with the same name.
@@ skipping 51 matching lines @@
 - (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();
+  // Unregister all observers before closing all the tabs.
+  for (const auto& webStateListObserver : _webStateListObservers)
+    _webStateList->RemoveObserver(webStateListObserver.get());
+  _webStateListObservers.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];
 }
@@ skipping 25 matching lines @@
 
 - (BOOL)isEmpty {
   return _webStateList->empty();
 }
 
 - (NSUInteger)count {
   DCHECK_GE(_webStateList->count(), 0);
   return static_cast<NSUInteger>(_webStateList->count());
 }
 
+- (WebStateList*)webStateList {
+  return _webStateList.get();
+}
+
 - (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>(
@@ skipping 13 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(
+    _webStateListObservers.push_back(
         base::MakeUnique<SnapshotCacheWebStateListObserver>(
             [SnapshotCache sharedInstance]));
     if (_tabUsageRecorder) {
-      _observerBridges.push_back(
+      _webStateListObservers.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()]));
+    _webStateListObservers.push_back(base::MakeUnique<TabParentingObserver>());
+    _webStateListObservers.push_back(
+        base::MakeUnique<WebStateListObserverBridge>(
+            [[TabModelSelectedTabObserver alloc] initWithTabModel:self]));
+    _webStateListObservers.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));
+    _webStateListObservers.push_back(std::move(webStateListMetricsObserver));
 
-    for (const auto& observerBridge : _observerBridges)
-      _webStateList->AddObserver(observerBridge.get());
+    for (const auto& webStateListObserver : _webStateListObservers)
+      _webStateList->AddObserver(webStateListObserver.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 605 matching lines @@
 }
 
 // Called when UIApplicationWillEnterForegroundNotification is received.
 - (void)applicationWillEnterForeground:(NSNotification*)notify {
   if (_tabUsageRecorder) {
     _tabUsageRecorder->AppWillEnterForeground();
   }
 }
 
 @end