Removing iPad Tab Switcher experimental flag.

ios/chrome/app/main_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/app/main_controller.h"
 
 #include <memory>
 #include <string>
 
 #import <CoreSpotlight/CoreSpotlight.h>
@@ skipping 516 matching lines @@
 // corresponding function to return YES.
 // Initializes the application to INITIALIZATION_STAGE_BASIC, which is the
 // minimum initialization needed in all cases.
 - (void)startUpBrowserBasicInitialization;
 // Initializes the application to INITIALIZATION_STAGE_BACKGROUND, which is
 // needed by background handlers.
 - (void)startUpBrowserBackgroundInitialization;
 // Initializes the application to INITIALIZATION_STAGE_FOREGROUND, which is
 // needed when application runs in foreground.
 - (void)startUpBrowserForegroundInitialization;
-// Swaps the UI between Incognito and normal modes.
-- (void)swapBrowserModes;
 @end
 
 @implementation MainController
 
 @synthesize appState = _appState;
 @synthesize appLaunchTime = _appLaunchTime;
 @synthesize browserInitializationStage = _browserInitializationStage;
 @synthesize window = _window;
 @synthesize isPresentingFirstRunUI = _isPresentingFirstRunUI;
 @synthesize isColdStart = _isColdStart;
@@ skipping 264 matching lines @@
   };
   [self.browsingDataRemovalController
       removeIOSSpecificIncognitoBrowsingDataFromBrowserState:otrBrowserState
                                                         mask:removeAllMask
                                            completionHandler:completion];
 }
 
 - (void)deleteIncognitoBrowserState {
   BOOL otrBVCIsCurrent = (self.currentBVC == self.otrBVC);
 
-  const BOOL isOnIPadWithTabSwitcherEnabled =
-      IsIPadIdiom() && experimental_flags::IsTabSwitcherEnabled();
-
   // If the current BVC is the otr BVC, then the user should be in the card
   // stack, this is not true for the iPad tab switcher.
-  DCHECK(isOnIPadWithTabSwitcherEnabled ||
-         (!otrBVCIsCurrent || _tabSwitcherIsActive));
+  DCHECK(IsIPadIdiom() || (!otrBVCIsCurrent || _tabSwitcherIsActive));
 
   // We always clear the otr tab model on iPad.
   // Notify the _tabSwitcherController that its otrBVC will be destroyed.
-  if (isOnIPadWithTabSwitcherEnabled || _tabSwitcherIsActive)
+  if (IsIPadIdiom() || _tabSwitcherIsActive)
     [_tabSwitcherController setOtrTabModel:nil];
 
   [_browserViewWrangler
       deleteIncognitoTabModelState:self.browsingDataRemovalController];
 
   if (otrBVCIsCurrent) {
     [self activateBVCAndMakeCurrentBVCPrimary];
   }
 
   // Always set the new otr tab model on iPad with tab switcher enabled.
   // Notify the _tabSwitcherController with the new otrBVC.
-  if (isOnIPadWithTabSwitcherEnabled || _tabSwitcherIsActive)
+  if (IsIPadIdiom() || _tabSwitcherIsActive)
     [_tabSwitcherController setOtrTabModel:self.otrTabModel];
 }
 
 - (BrowsingDataRemovalController*)browsingDataRemovalController {
   if (!_browsingDataRemovalController) {
     _browsingDataRemovalController.reset(
         [[BrowsingDataRemovalController alloc] initWithDelegate:self]);
   }
   return _browsingDataRemovalController;
 }
@@ skipping 579 matching lines @@
   switch (command) {
     case IDC_NEW_TAB:
       [self createNewTabInBVC:self.mainBVC sender:sender];
       break;
     case IDC_NEW_INCOGNITO_TAB:
       [self createNewTabInBVC:self.otrBVC sender:sender];
       break;
     case IDC_OPEN_URL:
       [self openUrl:base::mac::ObjCCast<OpenUrlCommand>(sender)];
       break;
-    case IDC_SWITCH_BROWSER_MODES:
-      DCHECK(IsIPadIdiom());
-      [self swapBrowserModes];
-      break;
     case IDC_OPTIONS:
       [self showSettings];
       break;
     case IDC_REPORT_AN_ISSUE:
       dispatch_async(dispatch_get_main_queue(), ^{
         [self showReportAnIssue];
       });
       break;
     case IDC_SHOW_SIGNIN_IOS: {
       ShowSigninCommand* command =
@@ skipping 18 matching lines @@
       [self showSyncEncryptionPassphrase];
       break;
     case IDC_SHOW_SAVE_PASSWORDS_SETTINGS:
       [self showSavePasswordsSettings];
       break;
     case IDC_SHOW_HISTORY:
       [self showHistory];
       break;
     case IDC_TOGGLE_TAB_SWITCHER:
       DCHECK(!_tabSwitcherIsActive);
-      if ((!IsIPadIdiom() || experimental_flags::IsTabSwitcherEnabled()) &&
-          !_isProcessingVoiceSearchCommand) {
+      if (!_isProcessingVoiceSearchCommand) {
         [self showTabSwitcher];
         _isProcessingTabSwitcherCommand = YES;
         dispatch_after(dispatch_time(DISPATCH_TIME_NOW,
                                      kExpectedTransitionDurationInNanoSeconds),
                        dispatch_get_main_queue(), ^{
                          _isProcessingTabSwitcherCommand = NO;
                        });
       }
       break;
     case IDC_PRELOAD_VOICE_SEARCH:
@@ skipping 196 matching lines @@
   // b) The second condition can happen if some other code (like JS) triggers
   // closure of tabs from the otr tab model when it's not current.
   // Nothing to do here. The next user action (like clicking on an existing
   // regular tab or creating a new incognito tab from the settings menu) will
   // take care of the logic to mode switch.
   if (_tabSwitcherIsActive || ![self.currentTabModel isOffTheRecord]) {
     return;
   }
 
   if (IsIPadIdiom()) {
-    if (experimental_flags::IsTabSwitcherEnabled()) {
-      [self showTabSwitcher];
-    } else {
-      // Mode switch if not in regular mode.
-      [self swapBrowserModes];
-    }
+    [self showTabSwitcher];
   } else {
     self.currentBVC = self.mainBVC;
     if ([self.currentTabModel count] == 0U) {
       [self showTabSwitcher];
     }
   }
 }
 
 - (void)lastRegularTabClosed {
   // a) The first condition can happen when the last regular tab is closed from
   // the tab switcher.
   // b) The second condition can happen if some other code (like JS) triggers
   // closure of tabs from the main tab model when the main tab model is not
   // current.
   // Nothing to do here.
   if (_tabSwitcherIsActive || [self.currentTabModel isOffTheRecord]) {
     return;
   }
 
-  if (IsIPadIdiom()) {
-    if (experimental_flags::IsTabSwitcherEnabled()) {
-      [self showTabSwitcher];
-    }
-  } else {
-    [self showTabSwitcher];
-  }
+  [self showTabSwitcher];
 }
 
 #pragma mark - Mode Switching
 
 - (void)switchGlobalStateToMode:(ApplicationMode)mode {
   const BOOL incognito = (mode == ApplicationMode::INCOGNITO);
   // Write the state to disk of what is "active".
   NSUserDefaults* standardDefaults = [NSUserDefaults standardUserDefaults];
   [standardDefaults setBool:incognito forKey:kIncognitoCurrentKey];
   // Save critical state information for switching between normal and
@@ skipping 21 matching lines @@
 }
 
 - (TabModel*)currentTabModel {
   return self.currentBVC.tabModel;
 }
 
 - (ios::ChromeBrowserState*)currentBrowserState {
   return self.currentBVC.browserState;
 }
 
-- (void)swapBrowserModes {
-  if (self.mainBVC == self.currentBVC)
-    self.currentBVC = self.otrBVC;
-  else
-    self.currentBVC = self.mainBVC;
-  // Make sure there is at least one tab open.
-  if ([self shouldOpenNTPTabOnActivationOfTabModel:[self currentTabModel]])
-    [self.currentBVC newTab:nil];
-  [_browserViewWrangler updateModeToggle];
-}
-
 // NOTE: If you change this function, it may have an effect on the performance
 // of opening the stack view. Please make sure you also change the corresponding
 // code in StackViewControllerPerfTest::MainControllerShowTabSwitcher().
 - (void)showTabSwitcher {
   BrowserViewController* currentBVC = self.currentBVC;
   Tab* currentTab = [[currentBVC tabModel] currentTab];
 
   // In order to generate the transition between the current browser view
   // controller and the tab switcher controller it's possible that multiple
   // screenshots of the same tab are taken. Since taking a screenshot is
   // expensive we activate snapshot coalescing in the scope of this function
   // which will cache the first snapshot for the tab and reuse it instead of
   // regenerating a new one each time.
   [currentTab setSnapshotCoalescingEnabled:YES];
   base::ScopedClosureRunner runner(base::BindBlock(^{
     [currentTab setSnapshotCoalescingEnabled:NO];
   }));
 
-  if (experimental_flags::IsTabSwitcherEnabled())
-    [currentBVC prepareToEnterTabSwitcher:nil];
+  [currentBVC prepareToEnterTabSwitcher:nil];
 
   if (!_tabSwitcherController.get()) {
     if (IsIPadIdiom()) {
       _tabSwitcherController.reset([[TabSwitcherController alloc]
           initWithBrowserState:_mainBrowserState
                   mainTabModel:self.mainTabModel
                    otrTabModel:self.otrTabModel
                 activeTabModel:self.currentTabModel]);
     } else {
       _tabSwitcherController.reset([[StackViewController alloc]
           initWithMainTabModel:self.mainTabModel
                    otrTabModel:self.otrTabModel
                 activeTabModel:self.currentTabModel]);
     }
   } else {
     // The StackViewController is kept in memory to avoid the performance hit of
     // loading from the nib on next showing, but clears out its card models to
     // release memory.  The tab models are required to rebuild the card stacks.
     [_tabSwitcherController
         restoreInternalStateWithMainTabModel:self.mainTabModel
                                  otrTabModel:self.otrTabModel
                               activeTabModel:self.currentTabModel];
   }
   _tabSwitcherIsActive = YES;
   [_tabSwitcherController setDelegate:self];
-  if (IsIPadIdiom() && experimental_flags::IsTabSwitcherEnabled()) {
+  if (IsIPadIdiom()) {
     TabSwitcherTransitionContext* transitionContext =
         [TabSwitcherTransitionContext
             tabSwitcherTransitionContextWithCurrent:currentBVC
                                             mainBVC:self.mainBVC
                                              otrBVC:self.otrBVC];
     [_tabSwitcherController setTransitionContext:transitionContext];
     self.mainViewController.activeViewController = _tabSwitcherController;
     [_tabSwitcherController showWithSelectedTabAnimation];
   } else {
     // User interaction is disabled when the stack controller is dismissed.
@@ skipping 62 matching lines @@
 - (void)tabSwitcher:(id<TabSwitcher>)tabSwitcher
     dismissTransitionWillStartWithActiveModel:(TabModel*)tabModel {
   [self beginDismissingStackViewWithCurrentModel:tabModel];
 }
 
 - (void)tabSwitcherDismissTransitionDidEnd:(id<TabSwitcher>)tabSwitcher {
   [self finishDismissingStackView];
 }
 
 - (void)beginDismissingStackViewWithCurrentModel:(TabModel*)tabModel {
-  DCHECK(experimental_flags::IsTabSwitcherEnabled() || !IsIPadIdiom());
   DCHECK(tabModel == self.mainTabModel || tabModel == self.otrTabModel);
 
   _dismissingStackView = YES;
   // Prevent wayward touches from wreaking havoc while the stack view is being
   // dismissed.
   [[_tabSwitcherController view] setUserInteractionEnabled:NO];
   BrowserViewController* targetBVC =
       (tabModel == self.mainTabModel) ? self.mainBVC : self.otrBVC;
   self.currentBVC = targetBVC;
 }
 
 - (void)finishDismissingStackView {
-  DCHECK(!IsIPadIdiom() || experimental_flags::IsTabSwitcherEnabled());
   DCHECK_EQ(self.mainViewController.activeViewController,
             _tabSwitcherController.get());
 
   if (_modeToDisplayOnStackViewDismissal == StackViewDismissalMode::NORMAL) {
     self.currentBVC = self.mainBVC;
   } else if (_modeToDisplayOnStackViewDismissal ==
              StackViewDismissalMode::INCOGNITO) {
     self.currentBVC = self.otrBVC;
   }
 
@@ skipping 700 matching lines @@
   };
 
   callbackCounter->IncrementCount();
   [self removeBrowsingDataFromBrowserState:_mainBrowserState
                                       mask:removeAllMask
                                 timePeriod:browsing_data::ALL_TIME
                          completionHandler:decrementCallbackCounterCount];
 }
 
 @end