Fix for voice-over accessibility issue with tab switcher.

ios/chrome/browser/ui/tab_switcher/tab_switcher_panel_controller.mm

 // Copyright 2015 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/ui/tab_switcher/tab_switcher_panel_controller.h"
 
 #include "base/logging.h"
+#import "base/mac/foundation_util.h"
 #import "base/mac/scoped_nsobject.h"
 #include "base/strings/sys_string_conversions.h"
 #import "ios/chrome/browser/tabs/tab.h"
 #include "ios/chrome/browser/ui/ntp/recent_tabs/synced_sessions.h"
 #import "ios/chrome/browser/ui/tab_switcher/tab_switcher_cache.h"
 #import "ios/chrome/browser/ui/tab_switcher/tab_switcher_panel_cell.h"
 #import "ios/chrome/browser/ui/tab_switcher/tab_switcher_panel_overlay_view.h"
 #import "ios/chrome/browser/ui/tab_switcher/tab_switcher_panel_view.h"
 #include "ios/chrome/browser/ui/tab_switcher/tab_switcher_session_changes.h"
 
 namespace {
 
 void FillVectorWithHashesUsingDistantSession(
     synced_sessions::DistantSession const& session,
     std::vector<size_t>* hashes) {
   DCHECK(hashes);
   DCHECK(hashes->empty());
   for (size_t i = 0; i < session.tabs.size(); ++i) {
     hashes->push_back(session.tabs[i]->hashOfUserVisibleProperties());
   }
 }
 
 }  // namespace
 
 @interface TabSwitcherPanelController ()<UICollectionViewDataSource,
+                                         UICollectionViewDelegate,
                                          SessionCellDelegate> {
   ios::ChromeBrowserState* _browserState;  // Weak.
   base::scoped_nsobject<TabSwitcherPanelView> _panelView;
   base::scoped_nsobject<TabSwitcherModel> _model;
   std::string _sessionTag;
   TabSwitcherSessionType _sessionType;
   base::scoped_nsobject<TabSwitcherCache> _cache;
   base::scoped_nsobject<TabSwitcherPanelOverlayView> _overlayView;
   std::unique_ptr<const synced_sessions::DistantSession> _distantSession;
   std::unique_ptr<const TabModelSnapshot> _localSession;
@@ skipping 165 matching lines @@
   } else {
     CHECK(_localSession);
     NSInteger numberOfTabs = _localSession->tabs().size();
     [self setZeroTabStateOverlayVisible:numberOfTabs == 0];
     return numberOfTabs;
   }
 }
 
 - (UICollectionViewCell*)collectionView:(UICollectionView*)collectionView
                  cellForItemAtIndexPath:(NSIndexPath*)indexPath {
-  UICollectionViewCell* cell = nil;
+  TabSwitcherSessionCell* cell = nil;
   NSUInteger tabIndex = indexPath.item;
   if (_sessionType == TabSwitcherSessionType::DISTANT_SESSION) {
-    cell = [collectionView
-        dequeueReusableCellWithReuseIdentifier:[TabSwitcherDistantSessionCell
-                                                   identifier]
-                                  forIndexPath:indexPath];
-    DCHECK([cell isKindOfClass:[TabSwitcherDistantSessionCell class]]);
+    NSString* identifier = [TabSwitcherDistantSessionCell identifier];
     TabSwitcherDistantSessionCell* panelCell =
-        static_cast<TabSwitcherDistantSessionCell*>(cell);
+        base::mac::ObjCCastStrict<TabSwitcherDistantSessionCell>([collectionView
+            dequeueReusableCellWithReuseIdentifier:identifier
+                                      forIndexPath:indexPath]);
+    cell = panelCell;
+
     CHECK(_distantSession);
     const std::size_t distantSessionTabCount = _distantSession->tabs.size();
     LOG_ASSERT(tabIndex < distantSessionTabCount)
         << "tabIndex == " << tabIndex
         << " _distantSession->tabs.size() == " << distantSessionTabCount;
     synced_sessions::DistantTab* tab = _distantSession->tabs[tabIndex].get();
     CHECK(tab);
     [panelCell setTitle:SysUTF16ToNSString(tab->title)];
     [panelCell setSessionGURL:tab->virtual_url
              withBrowserState:[_model browserState]];
-    [panelCell setDelegate:self];
   } else {
-    cell = [collectionView
-        dequeueReusableCellWithReuseIdentifier:[TabSwitcherLocalSessionCell
-                                                   identifier]
-                                  forIndexPath:indexPath];
-    DCHECK([cell isKindOfClass:[TabSwitcherLocalSessionCell class]]);
+    NSString* identifier = [TabSwitcherLocalSessionCell identifier];
     TabSwitcherLocalSessionCell* panelCell =
-        static_cast<TabSwitcherLocalSessionCell*>(cell);
+        base::mac::ObjCCastStrict<TabSwitcherLocalSessionCell>([collectionView
+            dequeueReusableCellWithReuseIdentifier:identifier
+                                      forIndexPath:indexPath]);
+    cell = panelCell;
+
     Tab* tab = _localSession->tabs()[tabIndex];
-    [panelCell setDelegate:self];
     [panelCell setSessionType:_sessionType];
     [panelCell setAppearanceForTab:tab cellSize:[_panelView cellSize]];
   }
+  DCHECK(cell);
+  cell.delegate = self;
   return cell;
 }
 
+- (void)collectionView:(UICollectionView*)collectionView
+    didEndDisplayingCell:(UICollectionViewCell*)cell
+      forItemAtIndexPath:(NSIndexPath*)indexPath {
+  // When closing the last tab, accessibility does not realize that there is no
+  // elements in the collection view and keep the custom action for the tab. So
+  // reset the delegate of the cell (to avoid crashing if the action is invoked)
+  // and post a notification that the screen changed to force accessibility to
+  // re-inspect the whole screen. See http://crbug.com/677374 for crash log.
+  base::mac::ObjCCastStrict<TabSwitcherSessionCell>(cell).delegate = nil;
+  UIAccessibilityPostNotification(UIAccessibilityScreenChangedNotification,
+                                  nil);
+}
+
 #pragma mark - SessionCellDelegate
 
 - (TabSwitcherCache*)tabSwitcherCache {
   return _cache;
 }
 
 - (void)cellPressed:(UICollectionViewCell*)cell {
   const NSInteger tabIndex =
       [[_panelView collectionView] indexPathForCell:cell].item;
 
@@ skipping 54 matching lines @@
                  [self.delegate
                      tabSwitcherPanelControllerDidUpdateOverlayViewVisibility:
                          self];
                }];
 }
 
 - (void)loadView {
   _panelView.reset(
       [[TabSwitcherPanelView alloc] initWithSessionType:_sessionType]);
   _panelView.get().collectionView.dataSource = self;
+  _panelView.get().collectionView.delegate = self;
 }
 
 - (synced_sessions::DistantSession const*)distantSession {
   return _distantSession.get();
 }
 
 @end