Fix tabs are not rendered properly when restore tabs after crash on iPad

ios/chrome/browser/ui/tabs/tab_strip_controller.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/ui/tabs/tab_strip_controller.h"
 #import "ios/chrome/browser/ui/tabs/tab_strip_controller_private.h"
 
 #include <cmath>
 #include <vector>
 
@@ skipping 268 matching lines @@
 // current position.  (If dropped, the tab would be at this index in the model.)
 // TODO(rohitrao): Implement this method.
 - (NSUInteger)modelIndexForDraggedTab;
 #endif
 
 // Returns the horizontal visible tab strip width used to compute the tab width
 // and the tabs and new tab button in regular layout mode.
 // Takes into account whether or not the mode toggle button is showing.
 - (CGFloat)tabStripVisibleSpace;
 
+// Shift all of the tab strip subviews by an amount equal to the content offset
+// change, which effectively places the subviews back where they were before the
+// change, in terms of screen coordinates.
+- (void)shiftTabStripSubviews:(CGPoint)oldContentOffset;
+
 // Updates the scroll view's content size based on the current set of tabs and
 // closing tabs.  After updating the content size, repositions views so they
 // they will appear stationary on screen.
 - (void)updateContentSizeAndRepositionViews;
 
 // Returns the frame, in the scroll view content's coordinate system, of the
 // given tab view.
 - (CGRect)scrollViewFrameForTab:(TabView*)view;
 
 // Returns the portion of |frame| which is not covered by |frameOnTop|.
 - (CGRect)calculateVisibleFrameForFrame:(CGRect)frame
                          whenUnderFrame:(CGRect)frameOnTop;
 
 // Schedules a layout of the scroll view and sets the internal |_animateLayout|
 // flag so that the layout will be animated.
 - (void)setNeedsLayoutWithAnimation;
 
 // Returns the maximum number of collapsed tabs depending on the current layout
 // mode.
 - (NSUInteger)maxNumCollapsedTabs;
 
 // Returns the tab overlap width depending on the current layout mode.
 - (CGFloat)tabOverlap;
 
 // Returns the minimum tab view width depending on the current layout mode.
 - (CGFloat)minTabWidth;
 
+// Automatically scroll the tab strip view to keep the newly inserted tab view
+// visible.
+// This method must be called with a valid |tabIndex|.
+- (void)autoScrollForNewTab:(NSUInteger)tabIndex;
+
 // Updates the content offset of the tab strip view in order to keep the
 // selected tab view visible.
 // Content offset adjustement is only needed/performed in compact mode or
 // regular mode for newly opened tabs.
 // This method must be called with a valid |tabIndex|.
 - (void)updateContentOffsetForTabIndex:(NSUInteger)tabIndex
                               isNewTab:(BOOL)isNewTab;
 
 // Update the frame of the tab strip view (scrollview) frame, content inset and
 // toggle buttons states depending on the current layout mode.
@@ skipping 836 matching lines @@
 
 - (void)removeTabSwitcherToggleButton {
   // Remove the button view.
   DCHECK(_tabSwitcherToggleButton);
   [_tabSwitcherToggleButton removeFromSuperview];
   _tabSwitcherToggleButton = nil;
   // Extend the scroll view.
   [self updateScrollViewFrameForToggleButton];
 }
 
+- (void)shiftTabStripSubviews:(CGPoint)oldContentOffset {
+  CGFloat dx = [_tabStripView contentOffset].x - oldContentOffset.x;
+  for (UIView* view in [_tabStripView subviews]) {
+    CGRect frame = [view frame];
+    frame.origin.x += dx;
+    [view setFrame:frame];
+    _targetFrames.AddFrame(view, frame);
+  }
+}
+
 - (void)updateContentSizeAndRepositionViews {
   // TODO(rohitrao): The following lines are duplicated in
   // layoutTabStripSubviews.  Find a way to consolidate this logic.
   const NSUInteger tabCount = [_tabArray count] - [_closingTabs count];
   if (!tabCount)
     return;
   const CGFloat tabHeight = CGRectGetHeight([_tabStripView bounds]);
   CGFloat visibleSpace = [self tabStripVisibleSpace];
   _currentTabWidth =
       (visibleSpace + ([self tabOverlap] * (tabCount - 1))) / tabCount;
   _currentTabWidth = MIN(_currentTabWidth, kMaxTabWidth);
   _currentTabWidth = MAX(_currentTabWidth, [self minTabWidth]);
 
   // Set the content size to be large enough to contain all the tabs at the
   // desired width, with the standard overlap, plus the new tab button.
   CGSize contentSize = CGSizeMake(
       _currentTabWidth * tabCount - ([self tabOverlap] * (tabCount - 1)) +
           CGRectGetWidth([_buttonNewTab frame]) - kNewTabOverlap,
       tabHeight);
   if (CGSizeEqualToSize([_tabStripView contentSize], contentSize))
     return;
 
   // Background: The scroll view might change the content offset when updating
   // the content size.  This can happen when the old content offset would result
   // in an overscroll at the new content size.  (Note that the content offset
   // will never change if the content size is growing.)
   //
   // To handle this without making views appear to jump, shift all of the
-  // subviews by an amount equal to the size change.  This effectively places
-  // the subviews back where they were before the change, in terms of screen
-  // coordinates.
+  // subviews by an amount equal to the size change.
   CGPoint oldOffset = [_tabStripView contentOffset];
   [_tabStripView setContentSize:contentSize];
-
-  CGFloat dx = [_tabStripView contentOffset].x - oldOffset.x;
-  for (UIView* view in [_tabStripView subviews]) {
-    CGRect frame = [view frame];
-    frame.origin.x += dx;
-    [view setFrame:frame];
-    _targetFrames.AddFrame(view, frame);
-  }
+  [self shiftTabStripSubviews:oldOffset];
 }
 
 - (CGRect)scrollViewFrameForTab:(TabView*)view {
   NSUInteger index = [self modelIndexForTabView:view];
 
   CGRect frame = [view frame];
   frame.origin.x =
       (_currentTabWidth * index) - ([self tabOverlap] * (index - 1));
   return frame;
 }
@@ skipping 22 matching lines @@
 }
 
 - (CGFloat)tabOverlap {
   return IsCompactTablet() ? kTabOverlapForCompactLayout : kTabOverlap;
 }
 
 - (CGFloat)minTabWidth {
   return IsCompactTablet() ? kMinTabWidthForCompactLayout : kMinTabWidth;
 }
 
+- (void)autoScrollForNewTab:(NSUInteger)tabIndex {
+  DCHECK_NE(NSNotFound, static_cast<NSInteger>(tabIndex));
+
+  // The following code calculates the amount of scroll needed to make
+  // |tabIndex| visible in the "virtual" coordinate system, where root is x=0
+  // and it contains all the tabs laid out as if the tabstrip was infinitely
+  // long. The amount of scroll is calculated as a desired length that it is
+  // just large enough to contain all the tabs to the left of |tabIndex|, with
+  // the standard overlap.
+  if (tabIndex == [_tabArray count] - 1) {
+    const CGFloat tabStripAvailableSpace =
+        _tabStripView.frame.size.width - _tabStripView.contentInset.right;
+    CGPoint oldOffset = [_tabStripView contentOffset];
+    if (_tabStripView.contentSize.width > tabStripAvailableSpace) {
+      CGFloat scrollToPoint =
+          _tabStripView.contentSize.width - tabStripAvailableSpace;
+      [_tabStripView setContentOffset:CGPointMake(scrollToPoint, 0)];
+    }
+
+    // To handle content offset change without making views appear to jump,
+    // shift all of the subviews by an amount equal to the size change.
+    [self shiftTabStripSubviews:oldOffset];
+    return;
+  }
+
+  NSUInteger numNonClosingTabsToLeft = 0;
+  NSUInteger i = 0;
+  for (TabView* tab in _tabArray.get()) {
+    if ([_closingTabs containsObject:tab])
+      ++i;
+
+    if (i == tabIndex)
+      break;
+
+    ++numNonClosingTabsToLeft;
+    ++i;
+  }
+
+  const CGFloat tabHeight = CGRectGetHeight([_tabStripView bounds]);
+  CGRect scrollRect =
+      CGRectMake(_currentTabWidth * numNonClosingTabsToLeft -
+                     ([self tabOverlap] * (numNonClosingTabsToLeft - 1)),
+                 0, _currentTabWidth, tabHeight);
+  [_tabStripView scrollRectToVisible:scrollRect animated:YES];
+}
+
 - (void)updateContentOffsetForTabIndex:(NSUInteger)tabIndex
                               isNewTab:(BOOL)isNewTab {
   DCHECK_NE(NSNotFound, static_cast<NSInteger>(tabIndex));
 
   if (experimental_flags::IsTabStripAutoScrollNewTabsEnabled() && isNewTab) {
-    // The following code calculates the amount of scroll needed to make
-    // |tabIndex| visible in the "virtual" coordinate system, where root is x=0
-    // and it contains all the tabs laid out as if the tabstrip was infinitely
-    // long. The amount of scroll is calculated as a desired length that it is
-    // just large enough to contain all the tabs to the left of |tabIndex|, with
-    // the standard overlap.
-    NSUInteger numNonClosingTabsToLeft = 0;
-    NSUInteger i = 0;
-    for (TabView* tab in _tabArray.get()) {
-      if ([_closingTabs containsObject:tab])
-        ++i;
-
-      if (i == tabIndex)
-        break;
-
-      ++numNonClosingTabsToLeft;
-      ++i;
-    }
-
-    const CGFloat tabHeight = CGRectGetHeight([_tabStripView bounds]);
-    CGRect scrollRect =
-        CGRectMake(_currentTabWidth * numNonClosingTabsToLeft -
-                       ([self tabOverlap] * (numNonClosingTabsToLeft - 1)),
-                   0, _currentTabWidth, tabHeight);
-    [_tabStripView scrollRectToVisible:scrollRect animated:YES];
+    [self autoScrollForNewTab:tabIndex];
     return;
   }
 
   if (IsCompactTablet()) {
     if (tabIndex == [_tabArray count] - 1) {
       const CGFloat tabStripAvailableSpace =
           _tabStripView.frame.size.width - _tabStripView.contentInset.right;
       if (_tabStripView.contentSize.width > tabStripAvailableSpace) {
         CGFloat scrollToPoint =
             _tabStripView.contentSize.width - tabStripAvailableSpace;
@@ skipping 394 matching lines @@
 
 @implementation TabStripController (Testing)
 
 - (TabView*)existingTabViewForTab:(Tab*)tab {
   NSUInteger tabIndex = [_tabModel indexOfTab:tab];
   NSUInteger tabViewIndex = [self indexForModelIndex:tabIndex];
   return [_tabArray objectAtIndex:tabViewIndex];
 }
 
 @end