[ios] Change WebStateListObserverBridge to use weak reference.

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 127 matching lines @@
   std::unique_ptr<WebStateList> _webStateList;
 
   // Helper providing NSFastEnumeration implementation over the WebStateList.
   base::scoped_nsobject<WebStateListFastEnumerationHelper>
       _fastEnumerationHelper;
 
   // WebStateListObservers reacting to modifications of the model (may send
   // notification, translate and forward events, update metrics, ...).
   std::vector<std::unique_ptr<WebStateListObserver>> _webStateListObservers;
 
+  // Strong references to id<WebStateListObserving> wrapped by non-owning
+  // WebStateListObserverBridges.
+  base::scoped_nsobject<NSArray<id<WebStateListObserving>>>
+      _retainedWebStateListObservers;
+
   // 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.
   const SessionID _sessionID;
@@ skipping 36 matching lines @@
   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;
 
-  [self closeAllTabs];
+  // Close all tabs. Do this in an @autoreleasepool as WebStateList observers
+  // will be notified (they are unregistered later). As some of them may be
+  // implemented in Objective-C and unregister themselves in their -dealloc
+  // method, ensure they -autorelease introduced by ARC are processed before
+  // the WebStateList destructor is called.
+  @autoreleasepool {
+    [self closeAllTabs];
+  }
 
   // Unregister all observers after closing all the tabs as some of them are
   // required to properly clean up the Tabs.
   for (const auto& webStateListObserver : _webStateListObservers)
     _webStateList->RemoveObserver(webStateListObserver.get());
   _webStateListObservers.clear();
+  _retainedWebStateListObservers.reset();
 
   _clearPoliciesTaskTracker.TryCancelAll();
 
   [super dealloc];
 }
 
 #pragma mark - Public methods
 
 - (Tab*)currentTab {
   web::WebState* webState = _webStateList->GetActiveWebState();
@@ skipping 55 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]);
 
-    _webStateListObservers.push_back(base::MakeUnique<
-                                     WebStateListObserverBridge>([
-        [TabModelClosingWebStateObserver alloc]
-        initWithTabModel:self
-          restoreService:IOSChromeTabRestoreServiceFactory::GetForBrowserState(
-                             _browserState)]));
+    base::scoped_nsobject<NSMutableArray<id<WebStateListObserving>>>
+        retainedWebStateListObservers([[NSMutableArray alloc] init]);
+
+    base::scoped_nsobject<TabModelClosingWebStateObserver>
+        tabModelClosingWebStateObserver([[TabModelClosingWebStateObserver alloc]
+            initWithTabModel:self
+              restoreService:IOSChromeTabRestoreServiceFactory::
+                                 GetForBrowserState(_browserState)]);
+    [retainedWebStateListObservers addObject:tabModelClosingWebStateObserver];
+
+    _webStateListObservers.push_back(
+        base::MakeUnique<WebStateListObserverBridge>(
+            tabModelClosingWebStateObserver));
+
     _webStateListObservers.push_back(
         base::MakeUnique<SnapshotCacheWebStateListObserver>(
             [SnapshotCache sharedInstance]));
     if (_tabUsageRecorder) {
       _webStateListObservers.push_back(
           base::MakeUnique<TabUsageRecorderWebStateListObserver>(
               _tabUsageRecorder.get()));
     }
     _webStateListObservers.push_back(base::MakeUnique<TabParentingObserver>());
+
+    base::scoped_nsobject<TabModelSelectedTabObserver>
+        tabModelSelectedTabObserver(
+            [[TabModelSelectedTabObserver alloc] initWithTabModel:self]);
+    [retainedWebStateListObservers addObject:tabModelSelectedTabObserver];
     _webStateListObservers.push_back(
         base::MakeUnique<WebStateListObserverBridge>(
-            [[TabModelSelectedTabObserver alloc] initWithTabModel:self]));
+            tabModelSelectedTabObserver));
+
+    base::scoped_nsobject<TabModelObserversBridge> tabModelObserversBridge(
+        [[TabModelObserversBridge alloc] initWithTabModel:self
+                                        tabModelObservers:_observers.get()]);
+    [retainedWebStateListObservers addObject:tabModelObserversBridge];
     _webStateListObservers.push_back(
-        base::MakeUnique<WebStateListObserverBridge>(
-            [[TabModelObserversBridge alloc]
-                 initWithTabModel:self
-                tabModelObservers:_observers.get()]));
+        base::MakeUnique<WebStateListObserverBridge>(tabModelObserversBridge));
 
     auto webStateListMetricsObserver =
         base::MakeUnique<WebStateListMetricsObserver>();
     _webStateListMetricsObserver = webStateListMetricsObserver.get();
     _webStateListObservers.push_back(std::move(webStateListMetricsObserver));
 
     for (const auto& webStateListObserver : _webStateListObservers)
       _webStateList->AddObserver(webStateListObserver.get());
+    _retainedWebStateListObservers.reset([retainedWebStateListObservers copy]);
 
     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 463 matching lines @@
 }
 
 // Called when UIApplicationWillEnterForegroundNotification is received.
 - (void)applicationWillEnterForeground:(NSNotification*)notify {
   if (_tabUsageRecorder) {
     _tabUsageRecorder->AppWillEnterForeground();
   }
 }
 
 @end