Upstream Chrome on iOS source code [1/11].

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>
+#import <objc/objc.h>
+#import <objc/runtime.h>
+
+#include "base/bind.h"
+#include "base/callback_helpers.h"
+#include "base/files/file_path.h"
+#include "base/ios/block_types.h"
+#import "base/mac/bind_objc_block.h"
+#include "base/mac/bundle_locations.h"
+#include "base/mac/foundation_util.h"
+#include "base/mac/objc_property_releaser.h"
+#import "base/mac/scoped_nsobject.h"
+#include "base/macros.h"
+#include "base/path_service.h"
+#include "base/strings/sys_string_conversions.h"
+#include "base/time/time.h"
+#include "components/component_updater/component_updater_service.h"
+#include "components/content_settings/core/browser/host_content_settings_map.h"
+#include "components/metrics/metrics_pref_names.h"
+#include "components/metrics/metrics_service.h"
+#include "components/prefs/pref_change_registrar.h"
+#include "components/reading_list/core/reading_list_switches.h"
+#include "components/signin/core/browser/signin_manager.h"
+#include "components/url_formatter/url_formatter.h"
+#include "components/web_resource/web_resource_pref_names.h"
+#import "ios/chrome/app/application_delegate/app_state.h"
+#import "ios/chrome/app/application_delegate/background_activity.h"
+#import "ios/chrome/app/application_delegate/metrics_mediator.h"
+#import "ios/chrome/app/application_delegate/url_opener.h"
+#include "ios/chrome/app/application_mode.h"
+#include "ios/chrome/app/chrome_app_startup_parameters.h"
+#import "ios/chrome/app/deferred_initialization_runner.h"
+#import "ios/chrome/app/main_controller_private.h"
+#import "ios/chrome/app/memory_monitor.h"
+#import "ios/chrome/app/safe_mode_crashing_modules_config.h"
+#import "ios/chrome/app/spotlight/spotlight_manager.h"
+#import "ios/chrome/app/spotlight/spotlight_util.h"
+#include "ios/chrome/app/startup/chrome_main_starter.h"
+#include "ios/chrome/app/startup/client_registration.h"
+#include "ios/chrome/app/startup/ios_chrome_main.h"
+#include "ios/chrome/app/startup/network_stack_setup.h"
+#include "ios/chrome/app/startup/provider_registration.h"
+#include "ios/chrome/app/startup/register_experimental_settings.h"
+#include "ios/chrome/app/startup/setup_debugging.h"
+#import "ios/chrome/app/startup_tasks.h"
+#include "ios/chrome/app/tests_hook.h"
+#import "ios/chrome/browser/app_startup_parameters.h"
+#include "ios/chrome/browser/application_context.h"
+#include "ios/chrome/browser/browser_state/chrome_browser_state.h"
+#include "ios/chrome/browser/browser_state/chrome_browser_state_manager.h"
+#include "ios/chrome/browser/browser_state/chrome_browser_state_removal_controller.h"
+#import "ios/chrome/browser/browsing_data/browsing_data_removal_controller.h"
+#include "ios/chrome/browser/browsing_data/ios_chrome_browsing_data_remover.h"
+#include "ios/chrome/browser/callback_counter.h"
+#include "ios/chrome/browser/chrome_paths.h"
+#include "ios/chrome/browser/chrome_url_constants.h"
+#import "ios/chrome/browser/chrome_url_util.h"
+#include "ios/chrome/browser/content_settings/host_content_settings_map_factory.h"
+#include "ios/chrome/browser/crash_loop_detection_util.h"
+#include "ios/chrome/browser/crash_report/breakpad_helper.h"
+#import "ios/chrome/browser/crash_report/crash_report_background_uploader.h"
+#import "ios/chrome/browser/crash_report/crash_restore_helper.h"
+#include "ios/chrome/browser/experimental_flags.h"
+#include "ios/chrome/browser/file_metadata_util.h"
+#import "ios/chrome/browser/first_run/first_run.h"
+#include "ios/chrome/browser/geolocation/omnibox_geolocation_controller.h"
+#include "ios/chrome/browser/ios_chrome_io_thread.h"
+#import "ios/chrome/browser/memory/memory_debugger_manager.h"
+#include "ios/chrome/browser/metrics/first_user_action_recorder.h"
+#import "ios/chrome/browser/metrics/previous_session_info.h"
+#import "ios/chrome/browser/net/cookie_util.h"
+#include "ios/chrome/browser/net/crl_set_fetcher.h"
+#include "ios/chrome/browser/pref_names.h"
+#include "ios/chrome/browser/prefs/pref_observer_bridge.h"
+#import "ios/chrome/browser/reading_list/reading_list_download_service.h"
+#import "ios/chrome/browser/reading_list/reading_list_download_service_factory.h"
+#include "ios/chrome/browser/search_engines/search_engines_util.h"
+#include "ios/chrome/browser/search_engines/template_url_service_factory.h"
+#import "ios/chrome/browser/share_extension/share_extension_service.h"
+#import "ios/chrome/browser/share_extension/share_extension_service_factory.h"
+#include "ios/chrome/browser/signin/authentication_service.h"
+#include "ios/chrome/browser/signin/authentication_service_factory.h"
+#include "ios/chrome/browser/signin/signin_manager_factory.h"
+#import "ios/chrome/browser/snapshots/snapshot_cache.h"
+#import "ios/chrome/browser/tabs/tab.h"
+#import "ios/chrome/browser/tabs/tab_model.h"
+#import "ios/chrome/browser/tabs/tab_model_observer.h"
+#import "ios/chrome/browser/ui/authentication/signed_in_accounts_view_controller.h"
+#import "ios/chrome/browser/ui/authentication/signin_interaction_controller.h"
+#import "ios/chrome/browser/ui/browser_view_controller.h"
+#import "ios/chrome/browser/ui/chrome_web_view_factory.h"
+#import "ios/chrome/browser/ui/commands/clear_browsing_data_command.h"
+#include "ios/chrome/browser/ui/commands/ios_command_ids.h"
+#import "ios/chrome/browser/ui/commands/open_url_command.h"
+#import "ios/chrome/browser/ui/commands/show_signin_command.h"
+#import "ios/chrome/browser/ui/contextual_search/contextual_search_metrics.h"
+#import "ios/chrome/browser/ui/contextual_search/touch_to_search_permissions_mediator.h"
+#import "ios/chrome/browser/ui/downloads/download_manager_controller.h"
+#import "ios/chrome/browser/ui/first_run/first_run_util.h"
+#import "ios/chrome/browser/ui/first_run/welcome_to_chrome_view_controller.h"
+#import "ios/chrome/browser/ui/fullscreen_controller.h"
+#import "ios/chrome/browser/ui/history/history_panel_view_controller.h"
+#import "ios/chrome/browser/ui/main/browser_view_wrangler.h"
+#import "ios/chrome/browser/ui/main/main_coordinator.h"
+#import "ios/chrome/browser/ui/main/main_view_controller.h"
+#import "ios/chrome/browser/ui/orientation_limiting_navigation_controller.h"
+#import "ios/chrome/browser/ui/promos/signin_promo_view_controller.h"
+#import "ios/chrome/browser/ui/settings/settings_navigation_controller.h"
+#import "ios/chrome/browser/ui/stack_view/stack_view_controller.h"
+#import "ios/chrome/browser/ui/tab_switcher/tab_switcher_controller.h"
+#import "ios/chrome/browser/ui/tabs/tab_strip_controller+tab_switcher_animation.h"
+#include "ios/chrome/browser/ui/ui_util.h"
+#import "ios/chrome/browser/ui/uikit_ui_util.h"
+#import "ios/chrome/browser/ui/util/top_view_controller.h"
+#import "ios/chrome/browser/ui/webui/chrome_web_ui_ios_controller_factory.h"
+#include "ios/chrome/browser/xcallback_parameters.h"
+#include "ios/chrome/grit/ios_strings.h"
+#include "ios/net/cookies/cookie_store_ios.h"
+#import "ios/net/crn_http_protocol_handler.h"
+#include "ios/public/provider/chrome/browser/chrome_browser_provider.h"
+#include "ios/public/provider/chrome/browser/distribution/app_distribution_provider.h"
+#import "ios/public/provider/chrome/browser/native_app_launcher/native_app_whitelist_manager.h"
+#include "ios/public/provider/chrome/browser/signin/chrome_identity_service.h"
+#import "ios/public/provider/chrome/browser/user_feedback/user_feedback_provider.h"
+#import "ios/third_party/material_components_ios/src/components/Typography/src/MaterialTypography.h"
+#import "ios/third_party/material_roboto_font_loader_ios/src/src/MaterialRobotoFontLoader.h"
+#include "ios/web/net/request_tracker_factory_impl.h"
+#include "ios/web/net/request_tracker_impl.h"
+#include "ios/web/net/web_http_protocol_handler_delegate.h"
+#include "ios/web/public/web_capabilities.h"
+#include "ios/web/public/web_state/web_state.h"
+#import "ios/web/public/web_view_creation_util.h"
+#include "ios/web/public/webui/web_ui_ios_controller_factory.h"
+#import "ios/web/web_state/ui/crw_web_controller.h"
+#include "mojo/edk/embedder/embedder.h"
+#import "net/base/mac/url_conversions.h"
+#include "net/url_request/url_request_context.h"
+#include "ui/base/l10n/l10n_util.h"
+
+namespace {
+
+// Preference key used to store which profile is current.
+NSString* kIncognitoCurrentKey = @"IncognitoActive";
+
+// Constants for deferred initialization of preferences observer.
+NSString* const kPrefObserverInit = @"PrefObserverInit";
+
+// Constants for deferring notifying the AuthenticationService of a new cold
+// start.
+NSString* const kAuthenticationServiceNotification =
+    @"AuthenticationServiceNotification";
+
+// Constants for deferring reseting the startup attempt count (to give the app
+// a little while to make sure it says alive).
+NSString* const kStartupAttemptReset = @"StartupAttempReset";
+
+// Constants for deferring memory debugging tools startup.
+NSString* const kMemoryDebuggingToolsStartup = @"MemoryDebuggingToolsStartup";
+
+// Constants for deferring memory monitoring startup.
+NSString* const kMemoryMonitoring = @"MemoryMonitoring";
+
+// Constants for deferred check if it is necessary to send pings to
+// Chrome distribution related services.
+NSString* const kSendInstallPingIfNecessary = @"SendInstallPingIfNecessary";
+
+// Constants for deferring check of native iOS apps installed.
+NSString* const kCheckNativeApps = @"CheckNativeApps";
+
+// Constants for deferred deletion of leftover user downloaded files.
+NSString* const kDeleteDownloads = @"DeleteDownloads";
+
+// Constants for deferred sending of queued feedback.
+NSString* const kSendQueuedFeedback = @"SendQueuedFeedback";
+
+// Constants for deferring the deletion of pre-upgrade crash reports.
+NSString* const kCleanupCrashReports = @"CleanupCrashReports";
+
+// Constants for deferring the deletion of old snapshots.
+NSString* const kPurgeSnapshots = @"PurgeSnapshots";
+
+// Constants for deferring startup Spotlight bookmark indexing.
+NSString* const kStartSpotlightBookmarksIndexing =
+    @"StartSpotlightBookmarksIndexing";
+
+// Constants for deferred initialization of dynamic application shortcut items.
+NSString* const kAddApplicationShortcutItems = @"AddApplicationShortcutItems";
+
+// Constants for deferred promo display.
+const NSTimeInterval kDisplayPromoDelay = 0.1;
+
+// A rough estimate of the expected duration of a view controller transition
+// animation. It's used to temporarily disable mutally exclusive chrome
+// commands that trigger a view controller presentation.
+const int64_t kExpectedTransitionDurationInNanoSeconds = 0.2 * NSEC_PER_SEC;
+
+// Adapted from chrome/browser/ui/browser_init.cc.
+void RegisterComponentsForUpdate() {
+  component_updater::ComponentUpdateService* cus =
+      GetApplicationContext()->GetComponentUpdateService();
+  DCHECK(cus);
+  base::FilePath path;
+  const bool success = PathService::Get(ios::DIR_USER_DATA, &path);
+  DCHECK(success);
+  // CRLSetFetcher attempts to load a CRL set from either the local disk or
+  // network.
+  GetApplicationContext()->GetCRLSetFetcher()->StartInitialLoad(cus, path);
+}
+
+// Unsynchronizes the cookie store associated to |browserState| on the IO
+// thread.
+void UnSynchronizeCookieStore(ios::ChromeBrowserState* browserState) {
+  DCHECK(browserState);
+  scoped_refptr<net::URLRequestContextGetter> getter =
+      browserState->GetRequestContext();
+  web::WebThread::PostTask(
+      web::WebThread::IO, FROM_HERE, base::BindBlock(^{
+        net::CookieStoreIOS* store = static_cast<net::CookieStoreIOS*>(
+            getter->GetURLRequestContext()->cookie_store());
+        store->UnSynchronize();
+      }));
+}
+
+// Returns YES if |url| matches chrome://newtab.
+BOOL IsURLNtp(const GURL& url) {
+  return UrlHasChromeScheme(url) && url.host() == kChromeUINewTabHost;
+}
+
+// Used to update the current BVC mode if a new tab is added while the stack
+// view is being dimissed.  This is different than ApplicationMode in that it
+// can be set to |NONE| when not in use.
+enum class StackViewDismissalMode { NONE, NORMAL, INCOGNITO };
+
+}  // namespace
+
+// TODO(crbug.com/673904): Remove once MDFRobotoFontLoader declares it directly.
+// MDFRobotoFontLoader implicitly implements MDCTypographyFontLoading but can't
+// declare it until MDC is public.
+@interface MDFRobotoFontLoader (MDCTypography)<MDCTypographyFontLoading>
+@end
+
+@interface MainController ()<BrowserStateStorageSwitching,
+                             BrowsingDataRemovalControllerDelegate,
+                             PrefObserverDelegate,
+                             SettingsNavigationControllerDelegate,
+                             TabModelObserver,
+                             TabSwitcherDelegate,
+                             UserFeedbackDataSource> {
+  IBOutlet UIWindow* _window;
+
+  // Weak; owned by the ChromeBrowserProvider.
+  ios::ChromeBrowserStateManager* _browserStateManager;
+
+  // The object that drives the Chrome startup/shutdown logic.
+  std::unique_ptr<IOSChromeMain> _chromeMain;
+
+  // The ChromeBrowserState associated with the main (non-OTR) browsing mode.
+  ios::ChromeBrowserState* _mainBrowserState;  // Weak.
+
+  // Coordinators used to run the Chrome UI; there will be one of these active
+  // at any given time, usually |_mainCoordinator|.
+  // Main coordinator, backing object for the property of the same name, which
+  // lazily initializes on access.
+  base::scoped_nsobject<MainCoordinator> _mainCoordinator;
+
+  // Wrangler to handle BVC and tab model creation, access, and related logic.
+  // Implements faetures exposed from this object through the
+  // BrowserViewInformation protocol.
+  base::scoped_nsobject<BrowserViewWrangler> _browserViewWrangler;
+
+  // Parameters received at startup time when the app is launched from another
+  // app.
+  base::scoped_nsobject<AppStartupParameters> _startupParameters;
+
+  // Whether Voice Search should be started upon tab switcher dismissal.
+  BOOL _startVoiceSearchAfterTabSwitcherDismissal;
+
+  // Whether the QR Scanner should be started upon tab switcher dismissal.
+  BOOL _startQRScannerAfterTabSwitcherDismissal;
+
+  // Navigation View controller for the settings.
+  base::scoped_nsobject<SettingsNavigationController>
+      _settingsNavigationController;
+
+  // View controller for switching tabs.
+  base::scoped_nsobject<UIViewController<TabSwitcher>> _tabSwitcherController;
+
+  // Controller to display the re-authentication flow.
+  base::scoped_nsobject<SigninInteractionController>
+      _signinInteractionController;
+
+  // The number of memory warnings that have been received in this
+  // foreground session.
+  int _foregroundMemoryWarningCount;
+
+  // The time at which to reset the OOM crash flag in the user defaults. This
+  // is used to handle receiving multiple memory warnings in short succession.
+  CFAbsoluteTime _outOfMemoryResetTime;
+
+  // YES while animating the dismissal of stack view.
+  BOOL _dismissingStackView;
+
+  // If not NONE, the current BVC should be switched to this BVC on completion
+  // of stack view dismissal.
+  StackViewDismissalMode _modeToDisplayOnStackViewDismissal;
+
+  // If YES, the tab switcher is currently active.
+  BOOL _tabSwitcherIsActive;
+
+  // True if the current session began from a cold start. False if the app has
+  // entered the background at least once since start up.
+  BOOL _isColdStart;
+
+  // Keeps track of the restore state during startup.
+  base::scoped_nsobject<CrashRestoreHelper> _restoreHelper;
+
+  // An object to record metrics related to the user's first action.
+  std::unique_ptr<FirstUserActionRecorder> _firstUserActionRecorder;
+
+  // RequestTrackerFactory to customize the behavior of the network stack.
+  std::unique_ptr<web::RequestTrackerFactoryImpl> _requestTrackerFactory;
+
+  // Configuration for the HTTP protocol handler.
+  std::unique_ptr<web::WebHTTPProtocolHandlerDelegate>
+      _httpProtocolHandlerDelegate;
+
+  // True if First Run UI (terms of service & sync sign-in) is being presented
+  // in a modal dialog.
+  BOOL _isPresentingFirstRunUI;
+
+  // The tab switcher command and the voice search commands can be sent by views
+  // that reside in a different UIWindow leading to the fact that the exclusive
+  // touch property will be ineffective and a command for processing both
+  // commands may be sent in the same run of the runloop leading to
+  // inconsistencies. Those two boolean indicate if one of those commands have
+  // been processed in the last 200ms in order to only allow processing one at
+  // a time.
+  // TODO(crbug.com/560296):  Provide a general solution for handling mutually
+  // exclusive chrome commands sent at nearly the same time.
+  BOOL _isProcessingTabSwitcherCommand;
+  BOOL _isProcessingVoiceSearchCommand;
+
+  // Bridge to listen to pref changes.
+  std::unique_ptr<PrefObserverBridge> _localStatePrefObserverBridge;
+
+  // Registrar for pref changes notifications to the local state.
+  PrefChangeRegistrar _localStatePrefChangeRegistrar;
+
+  // Clears browsing data from ChromeBrowserStates.
+  base::scoped_nsobject<BrowsingDataRemovalController>
+      _browsingDataRemovalController;
+
+  // The class in charge of showing/hiding the memory debugger when the
+  // appropriate pref changes.
+  base::scoped_nsobject<MemoryDebuggerManager> _memoryDebuggerManager;
+
+  base::mac::ObjCPropertyReleaser _propertyReleaser_MainController;
+
+  // Responsible for indexing chrome links (such as bookmarks, most likely...)
+  // in system Spotlight index.
+  base::scoped_nsobject<SpotlightManager> _spotlightManager;
+
+  // Cached launchOptions from -didFinishLaunchingWithOptions.
+  base::scoped_nsobject<NSDictionary> _launchOptions;
+
+  // View controller for displaying the history panel.
+  base::scoped_nsobject<UIViewController> _historyPanelViewController;
+
+  // Variable backing metricsMediator property.
+  base::WeakNSObject<MetricsMediator> _metricsMediator;
+
+  // Hander for the startup tasks, deferred or not.
+  base::scoped_nsobject<StartupTasks> _startupTasks;
+}
+
+// Pointer to the main view controller, always owned by the main window.
+@property(nonatomic, readonly) MainViewController* mainViewController;
+
+// The main coordinator, lazily created the first time it is accessed. Manages
+// the MainViewController. This property should not be accessed before the
+// browser has started up to the FOREGROUND stage.
+@property(nonatomic, readonly) MainCoordinator* mainCoordinator;
+
+// A property to track whether the QR Scanner should be started upon tab
+// switcher dismissal. It can only be YES if the QR Scanner experiment is
+// enabled.
+@property(nonatomic, readwrite) BOOL startQRScannerAfterTabSwitcherDismissal;
+
+// Activates browsing and enables web views if |enabled| is YES.
+// Disables browsing and purges web views if |enabled| is NO.
+// Must be called only on the main thread.
+- (void)setWebUsageEnabled:(BOOL)enabled;
+// Activates self.currentBVC iff the self.currentBVC can be made active.
+- (void)activateCurrentBVC;
+// Sets |currentBVC| as the root view controller for the window.
+- (void)displayCurrentBVC;
+// Shows the settings UI.
+- (void)showSettings;
+// Shows the accounts settings UI.
+- (void)showAccountsSettings;
+// Shows the Sync settings UI.
+- (void)showSyncSettings;
+// Shows the Save Passwords settings.
+- (void)showSavePasswordsSettings;
+// Invokes the sign in flow with the specified authentication operation and
+// invokes |callback| when finished.
+- (void)showSignInWithOperation:(AuthenticationOperation)operation
+              signInAccessPoint:(signin_metrics::AccessPoint)signInAccessPoint
+                       callback:(ShowSigninCommandCompletionCallback)callback;
+// Wraps a callback with one that first checks if sign-in was completed
+// successfully and the profile wasn't swapped before invoking.
+- (ShowSigninCommandCompletionCallback)successfulSigninCompletion:
+    (ProceduralBlock)callback;
+// Shows the Sync encryption passphrase (part of Settings).
+- (void)showSyncEncryptionPassphrase;
+// Shows the Native Apps Settings UI (part of Settings).
+- (void)showNativeAppsSettings;
+// Shows the Clear Browsing Data Settings UI (part of Settings).
+- (void)showClearBrowsingDataSettingsController;
+// Shows the Contextual search UI (part of Settings).
+- (void)showContextualSearchSettingsController;
+// Shows the tab switcher UI.
+- (void)showTabSwitcher;
+// Starts a voice search on the current BVC.
+- (void)startVoiceSearch;
+// Dismisses the tab switcher UI without animation into the given model.
+- (void)dismissTabSwitcherWithoutAnimationInModel:(TabModel*)tabModel;
+// Dismisses and clears |signinInteractionController|.
+- (void)dismissSigninInteractionController;
+// Called when the last incognito tab was closed.
+- (void)lastIncognitoTabClosed;
+// Called when the last regular tab was closed.
+- (void)lastRegularTabClosed;
+// Post a notification with name |notificationName| on the first available
+// run loop cycle.
+- (void)postNotificationOnNextRunLoopCycle:(NSString*)notificationName;
+// Opens a tab in the target BVC, and switches to it in a way that's appropriate
+// to the current UI, based on the |dismissModals| flag:
+// - If a modal dialog is showing and |dismissModals| is NO, the selected tab of
+// the main tab model will change in the background, but the view won't change.
+// - Otherwise, any modal view will be dismissed, the stack view will animate
+// out if it is showing, the target BVC will become active, and the new tab will
+// be shown.
+// If the current tab in |targetMode| is a NTP, it can be reused to open URL.
+- (Tab*)openSelectedTabInMode:(ApplicationMode)targetMode
+                      withURL:(const GURL&)url
+                   transition:(ui::PageTransition)transition;
+// Checks the target BVC's current tab's URL. If this URL is chrome://newtab,
+// loads |url| in this tab. Otherwise, open |url| in a new tab in the target
+// BVC.
+- (Tab*)openOrReuseTabInMode:(ApplicationMode)targetMode
+                     withURL:(const GURL&)url
+                  transition:(ui::PageTransition)transition;
+// Returns whether the restore infobar should be displayed.
+- (bool)mustShowRestoreInfobar;
+// Begins the process of dismissing the stack view with the given current model,
+// switching which BVC is suspended if necessary, but not updating the UI.
+- (void)beginDismissingStackViewWithCurrentModel:(TabModel*)tabModel;
+// Completes the process of dismissing the stack view, removing it from the
+// screen and showing the appropriate BVC.
+- (void)finishDismissingStackView;
+// Sets up self.currentBVC for testing by closing existing tabs.
+- (void)setUpCurrentBVCForTesting;
+// Opens an url.
+- (void)openUrl:(OpenUrlCommand*)command;
+// Opens an url from a link in the settings UI.
+- (void)openUrlFromSettings:(OpenUrlCommand*)command;
+// Switch all global states for the given mode (normal or incognito).
+- (void)switchGlobalStateToMode:(ApplicationMode)mode;
+// Updates the local storage, cookie store, and sets the global state.
+- (void)changeStorageFromBrowserState:(ios::ChromeBrowserState*)oldState
+                       toBrowserState:(ios::ChromeBrowserState*)newState;
+// Returns the set of the sessions ids of the tabs in the given |tabModel|.
+- (NSMutableSet*)liveSessionsForTabModel:(TabModel*)tabModel;
+// Purge the unused snapshots.
+- (void)purgeSnapshots;
+// Sets a LocalState pref marking the TOS EULA as accepted.
+- (void)markEulaAsAccepted;
+// Sends any feedback that happens to still be on local storage.
+- (void)sendQueuedFeedback;
+// Sets the iOS cookie policy to match that of the given browser state.
+- (void)setInitialCookiesPolicy:(ios::ChromeBrowserState*)browserState;
+// Called whenever an orientation change is received.
+- (void)orientationDidChange:(NSNotification*)notification;
+// Register to receive orientation change notification to update breakpad
+// report.
+- (void)registerForOrientationChangeNotifications;
+// Asynchronously creates the pref observers.
+- (void)schedulePrefObserverInitialization;
+// Asynchronously schedules a check for what other native iOS apps are currently
+// installed.
+- (void)scheduleCheckNativeApps;
+// Asynchronously schedules pings to distribution services.
+- (void)scheduleAppDistributionPings;
+// Asynchronously schedule the init of the memoryDebuggerManager.
+- (void)scheduleMemoryDebuggingTools;
+// Asynchronously kick off regular free memory checks.
+- (void)scheduleFreeMemoryMonitoring;
+// Asynchronously schedules the notification of the AuthenticationService.
+- (void)scheduleAuthenticationServiceNotification;
+// Asynchronously schedules the reset of the failed startup attempt counter.
+- (void)scheduleStartupAttemptReset;
+// Asynchronously schedules the cleanup of crash reports.
+- (void)scheduleCrashReportCleanup;
+// Asynchronously schedules the deletion of old snapshots.
+- (void)scheduleSnapshotPurge;
+// Schedules various cleanup tasks that are performed after launch.
+- (void)scheduleStartupCleanupTasks;
+// Schedules various tasks to be performed after the application becomes active.
+- (void)scheduleLowPriorityStartupTasks;
+// Schedules tasks that require a fully-functional BVC to be performed.
+- (void)scheduleTasksRequiringBVCWithBrowserState;
+// Schedules the deletion of user downloaded files that might be leftover
+// from the last time Chrome was run.
+- (void)scheduleDeleteDownloadsDirectory;
+// Returns whether or not the app can launch in incognito mode.
+- (BOOL)canLaunchInIncognito;
+// Determines which UI should be shown on startup, and shows it.
+- (void)createInitialUI:(ApplicationMode)launchMode;
+// Initializes the first run UI and presents it to the user.
+- (void)showFirstRunUI;
+// Schedules presentation of the first eligible promo found, if any.
+- (void)scheduleShowPromo;
+// Crashes the application if requested.
+- (void)crashIfRequested;
+// Returns the BrowsingDataRemovalController. Lazily creates one if necessary.
+- (BrowsingDataRemovalController*)browsingDataRemovalController;
+// Clears incognito data that is specific to iOS and won't be cleared by
+// deleting the browser state.
+- (void)clearIOSSpecificIncognitoData;
+// Deletes the incognito browser state.
+- (void)deleteIncognitoBrowserState;
+// Handles the notification that first run modal dialog UI is about to complete.
+- (void)handleFirstRunUIWillFinish;
+// Handles the notification that first run modal dialog UI completed.
+- (void)handleFirstRunUIDidFinish;
+// Performs synchronous browser state initialization steps.
+- (void)initializeBrowserState:(ios::ChromeBrowserState*)browserState;
+// Helper methods to initialize the application to a specific stage.
+// Setting |_browserInitializationStage| to a specific stage requires the
+// 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;
+
+#pragma mark - Application lifecycle
+
+- (instancetype)init {
+  if ((self = [super init])) {
+    _propertyReleaser_MainController.Init(self, [MainController class]);
+    _startupTasks.reset([[StartupTasks alloc] init]);
+  }
+  return self;
+}
+
+- (void)dealloc {
+  [[NSNotificationCenter defaultCenter] removeObserver:self];
+  net::HTTPProtocolHandlerDelegate::SetInstance(nullptr);
+  net::RequestTracker::SetRequestTrackerFactory(nullptr);
+  [NSObject cancelPreviousPerformRequestsWithTarget:self];
+  [super dealloc];
+}
+
+// This function starts up to only what is needed at each stage of the
+// initialization. It is possible to continue initialization later.
+- (void)startUpBrowserToStage:(BrowserInitializationStageType)stage {
+  if (_browserInitializationStage < INITIALIZATION_STAGE_BASIC &&
+      stage >= INITIALIZATION_STAGE_BASIC) {
+    [self startUpBrowserBasicInitialization];
+    _browserInitializationStage = INITIALIZATION_STAGE_BASIC;
+  }
+
+  if (_browserInitializationStage < INITIALIZATION_STAGE_BACKGROUND &&
+      stage >= INITIALIZATION_STAGE_BACKGROUND) {
+    [self startUpBrowserBackgroundInitialization];
+    _browserInitializationStage = INITIALIZATION_STAGE_BACKGROUND;
+  }
+
+  if (_browserInitializationStage < INITIALIZATION_STAGE_FOREGROUND &&
+      stage >= INITIALIZATION_STAGE_FOREGROUND) {
+    // When adding a new initialization flow, consider setting
+    // |_appState.userInteracted| at the appropriate time.
+    DCHECK(_appState.userInteracted);
+    [self startUpBrowserForegroundInitialization];
+    _browserInitializationStage = INITIALIZATION_STAGE_FOREGROUND;
+  }
+}
+
+- (void)startUpBrowserBasicInitialization {
+  _appLaunchTime = base::TimeTicks::Now();
+  _isColdStart = YES;
+
+  [SetupDebugging setUpDebuggingOptions];
+
+  // Register all providers before calling any Chromium code.
+  [ProviderRegistration registerProviders];
+}
+
+- (void)startUpBrowserBackgroundInitialization {
+  DCHECK(![self.appState isInSafeMode]);
+
+  NSBundle* baseBundle = base::mac::OuterBundle();
+  base::mac::SetBaseBundleID(
+      base::SysNSStringToUTF8([baseBundle bundleIdentifier]).c_str());
+
+  // Register default values for experimental settings (Application Preferences)
+  // and set the "Version" key in the UserDefaults.
+  [RegisterExperimentalSettings
+      registerExperimentalSettingsWithUserDefaults:[NSUserDefaults
+                                                       standardUserDefaults]
+                                            bundle:base::mac::
+                                                       FrameworkBundle()];
+
+  // Register all clients before calling any web code.
+  [ClientRegistration registerClients];
+
+  _chromeMain = [ChromeMainStarter startChromeMain];
+
+  // Initialize the ChromeBrowserProvider.
+  ios::GetChromeBrowserProvider()->Initialize();
+
+  // If the user is interacting, crashes affect the user experience. Start
+  // reporting as soon as possible.
+  // TODO(crbug.com/507633): Call this even sooner.
+  if (_appState.userInteracted)
+    GetApplicationContext()->GetMetricsService()->OnAppEnterForeground();
+
+  web::WebUIIOSControllerFactory::RegisterFactory(
+      ChromeWebUIIOSControllerFactory::GetInstance());
+
+  // TODO(crbug.com/546171): Audit all the following code to see if some of it
+  // should move into BrowserMainParts or BrowserProcess.
+
+  [NetworkStackSetup setUpChromeNetworkStack:&_requestTrackerFactory
+                 httpProtocolHandlerDelegate:&_httpProtocolHandlerDelegate];
+}
+
+- (void)startUpBrowserForegroundInitialization {
+  // Give tests a chance to prepare for testing.
+  tests_hook::SetUpTestsIfPresent();
+
+  GetApplicationContext()->OnAppEnterForeground();
+
+  // TODO(crbug.com/546171): Audit all the following code to see if some of it
+  // should move into BrowserMainParts or BrowserProcess.
+  NSUserDefaults* standardDefaults = [NSUserDefaults standardUserDefaults];
+
+  // Although this duplicates some metrics_service startup logic also in
+  // IOSChromeMain(), this call does additional work, checking for wifi-only
+  // and setting up the required support structures.
+  [_metricsMediator updateMetricsStateBasedOnPrefsUserTriggered:NO];
+
+  // Resets the number of crash reports that have been uploaded since the
+  // previous Foreground initialization.
+  [CrashReportBackgroundUploader resetReportsUploadedInBackgroundCount];
+
+  // Resets the interval stats between two background fetch as this value may be
+  // obsolete.
+  [BackgroundActivity foregroundStarted];
+
+  // Crash the app during startup if requested but only after we have enabled
+  // uploading crash reports.
+  [self crashIfRequested];
+
+  RegisterComponentsForUpdate();
+
+  if (experimental_flags::IsAlertOnBackgroundUploadEnabled()) {
+    if ([UIApplication instancesRespondToSelector:
+                           @selector(registerUserNotificationSettings:)]) {
+      [[UIApplication sharedApplication]
+          registerUserNotificationSettings:
+              [UIUserNotificationSettings
+                  settingsForTypes:UIUserNotificationTypeAlert |
+                                   UIUserNotificationTypeBadge |
+                                   UIUserNotificationTypeSound
+                        categories:nil]];
+    }
+  }
+
+  // Remove the extra browser states as Chrome iOS is single profile in M48+.
+  ChromeBrowserStateRemovalController::GetInstance()
+      ->RemoveBrowserStatesIfNecessary();
+
+  _browserStateManager =
+      GetApplicationContext()->GetChromeBrowserStateManager();
+  ios::ChromeBrowserState* chromeBrowserState =
+      _browserStateManager->GetLastUsedBrowserState();
+
+  // The CrashRestoreHelper must clean up the old browser state information
+  // before the tabModels can be created.  |_restoreHelper| must be kept alive
+  // until the BVC receives the browser state and tab model.
+  BOOL postCrashLaunch = [self mustShowRestoreInfobar];
+  if (postCrashLaunch) {
+    _restoreHelper.reset(
+        [[CrashRestoreHelper alloc] initWithBrowserState:chromeBrowserState]);
+    [_restoreHelper moveAsideSessionInformation];
+  }
+
+  // Initialize and set the main browser state.
+  [self initializeBrowserState:chromeBrowserState];
+  _mainBrowserState = chromeBrowserState;
+  _browserViewWrangler.reset([[BrowserViewWrangler alloc]
+      initWithBrowserState:_mainBrowserState
+          tabModelObserver:self]);
+  // Ensure the main tab model is created.
+  ignore_result([_browserViewWrangler mainTabModel]);
+
+  [self createSpotlightManager];
+
+  if (reading_list::switches::IsReadingListEnabled()) {
+    ShareExtensionService* service =
+        ShareExtensionServiceFactory::GetForBrowserState(_mainBrowserState);
+    service->Initialize();
+  }
+
+  // Before bringing up the UI, make sure the launch mode is correct, and
+  // check for previous crashes.
+  BOOL startInIncognito = [standardDefaults boolForKey:kIncognitoCurrentKey];
+  BOOL switchFromIncognito = startInIncognito && ![self canLaunchInIncognito];
+
+  if (postCrashLaunch || switchFromIncognito) {
+    [self clearIOSSpecificIncognitoData];
+    if (switchFromIncognito)
+      [self switchGlobalStateToMode:ApplicationMode::NORMAL];
+  }
+  if (switchFromIncognito)
+    startInIncognito = NO;
+
+  [self createInitialUI:(startInIncognito ? ApplicationMode::INCOGNITO
+                                          : ApplicationMode::NORMAL)];
+
+  [self scheduleStartupCleanupTasks];
+  [MetricsMediator logLaunchMetricsWithStartupInformation:self
+                                   browserViewInformation:_browserViewWrangler];
+
+  [self scheduleLowPriorityStartupTasks];
+
+  [_browserViewWrangler updateDeviceSharingManager];
+
+  [MDCTypography setFontLoader:[MDFRobotoFontLoader sharedInstance]];
+
+  [self openTabFromLaunchOptions:_launchOptions
+              startupInformation:self
+                        appState:self.appState];
+  _launchOptions.reset();
+
+  mojo::edk::Init();
+
+  if (!_startupParameters) {
+    // The startup parameters may create new tabs or navigations. If the restore
+    // infobar is displayed now, it may be dismissed immediately and the user
+    // will never be able to restore the session.
+    [_restoreHelper showRestoreIfNeeded:[self currentTabModel]];
+    _restoreHelper.reset();
+  }
+
+  [self scheduleTasksRequiringBVCWithBrowserState];
+
+  // Now that everything is properly set up, run the tests.
+  tests_hook::RunTestsIfPresent();
+}
+
+- (void)initializeBrowserState:(ios::ChromeBrowserState*)browserState {
+  DCHECK(!browserState->IsOffTheRecord());
+  [self setInitialCookiesPolicy:browserState];
+  search_engines::UpdateSearchEnginesIfNeeded(
+      browserState->GetPrefs(),
+      ios::TemplateURLServiceFactory::GetForBrowserState(browserState));
+
+  if ([TouchToSearchPermissionsMediator isTouchToSearchAvailableOnDevice]) {
+    base::scoped_nsobject<TouchToSearchPermissionsMediator>
+        touchToSearchPermissions([[TouchToSearchPermissionsMediator alloc]
+            initWithBrowserState:browserState]);
+    if (experimental_flags::IsForceResetContextualSearchEnabled()) {
+      [touchToSearchPermissions setPreferenceState:TouchToSearch::UNDECIDED];
+    }
+    ContextualSearch::RecordPreferenceState(
+        [touchToSearchPermissions preferenceState]);
+  }
+}
+
+- (void)handleFirstRunUIWillFinish {
+  DCHECK(_isPresentingFirstRunUI);
+  _isPresentingFirstRunUI = NO;
+  [[NSNotificationCenter defaultCenter]
+      removeObserver:self
+                name:kChromeFirstRunUIWillFinishNotification
+              object:nil];
+
+  [self markEulaAsAccepted];
+
+  if (_startupParameters.get()) {
+    [self dismissModalsAndOpenSelectedTabInMode:ApplicationMode::NORMAL
+                                        withURL:[_startupParameters externalURL]
+                                     transition:ui::PAGE_TRANSITION_LINK
+                                     completion:nil];
+    _startupParameters.reset();
+  }
+}
+
+- (void)handleFirstRunUIDidFinish {
+  [[NSNotificationCenter defaultCenter]
+      removeObserver:self
+                name:kChromeFirstRunUIDidFinishNotification
+              object:nil];
+
+  // As soon as First Run has finished, give OmniboxGeolocationController an
+  // opportunity to present the iOS system location alert.
+  [[OmniboxGeolocationController sharedInstance]
+      triggerSystemPromptForNewUser:YES];
+}
+
+- (void)clearIOSSpecificIncognitoData {
+  DCHECK(_mainBrowserState->HasOffTheRecordChromeBrowserState());
+  ios::ChromeBrowserState* otrBrowserState =
+      _mainBrowserState->GetOffTheRecordChromeBrowserState();
+  int removeAllMask = ~0;
+  [self.browsingDataRemovalController
+      removeIOSSpecificIncognitoBrowsingDataFromBrowserState:otrBrowserState
+                                                        mask:removeAllMask
+                                           completionHandler:^{
+                                             [self activateCurrentBVC];
+                                           }];
+}
+
+- (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));
+
+  // We always clear the otr tab model on iPad.
+  // Notify the _tabSwitcherController that its otrBVC will be destroyed.
+  if (isOnIPadWithTabSwitcherEnabled || _tabSwitcherIsActive)
+    [_tabSwitcherController setOtrTabModel:nil];
+
+  [_browserViewWrangler
+      deleteIncognitoTabModelState:self.browsingDataRemovalController];
+
+  if (otrBVCIsCurrent) {
+    [self activateCurrentBVC];
+  }
+
+  // Always set the new otr tab model on iPad with tab switcher enabled.
+  // Notify the _tabSwitcherController with the new otrBVC.
+  if (isOnIPadWithTabSwitcherEnabled || _tabSwitcherIsActive)
+    [_tabSwitcherController setOtrTabModel:self.otrTabModel];
+}
+
+- (BrowsingDataRemovalController*)browsingDataRemovalController {
+  if (!_browsingDataRemovalController) {
+    _browsingDataRemovalController.reset(
+        [[BrowsingDataRemovalController alloc] initWithDelegate:self]);
+  }
+  return _browsingDataRemovalController;
+}
+
+- (void)setWebUsageEnabled:(BOOL)enabled {
+  DCHECK([NSThread isMainThread]);
+  if (enabled) {
+    [self activateCurrentBVC];
+  } else {
+    [self.currentBVC setActive:enabled];
+  }
+}
+
+- (void)activateCurrentBVC {
+  // If there are pending removal operations, the activation will be deferred
+  // until the callback for |removeBrowsingDataFromBrowserState:| is received.
+  if (![self.browsingDataRemovalController
+          hasPendingRemovalOperations:self.currentBrowserState]) {
+    [self.currentBVC setActive:YES];
+    [self.currentBVC setPrimary:YES];
+  }
+}
+
+#pragma mark - BrowserLauncher implementation.
+
+- (NSDictionary*)launchOptions {
+  return _launchOptions;
+}
+
+- (void)setLaunchOptions:(NSDictionary*)launchOptions {
+  _launchOptions.reset([launchOptions retain]);
+}
+
+#pragma mark - Property implementation.
+
+- (id<BrowserViewInformation>)browserViewInformation {
+  return _browserViewWrangler;
+}
+
+- (AppStartupParameters*)startupParameters {
+  return _startupParameters;
+}
+
+- (void)setStartupParameters:(AppStartupParameters*)startupParameters {
+  _startupParameters.reset([startupParameters retain]);
+}
+
+- (MainViewController*)mainViewController {
+  return self.mainCoordinator.mainViewController;
+}
+
+- (MainCoordinator*)mainCoordinator {
+  if (_browserInitializationStage == INITIALIZATION_STAGE_BASIC) {
+    NOTREACHED() << "mainCoordinator accessed too early in initialization.";
+    return nil;
+  }
+  if (!_mainCoordinator) {
+    // Lazily create the main coordinator.
+    _mainCoordinator.reset(
+        [[MainCoordinator alloc] initWithWindow:self.window]);
+  }
+  return _mainCoordinator;
+}
+
+- (BOOL)isFirstLaunchAfterUpgrade {
+  return [[PreviousSessionInfo sharedInstance] isFirstSessionAfterUpgrade];
+}
+
+- (MetricsMediator*)metricsMediator {
+  return _metricsMediator;
+}
+
+- (void)setMetricsMediator:(MetricsMediator*)metricsMediator {
+  _metricsMediator.reset(metricsMediator);
+}
+
+- (SettingsNavigationController*)settingsNavigationController {
+  return _settingsNavigationController;
+}
+
+- (void)setSettingsNavigationController:
+    (SettingsNavigationController*)settingsNavigationController {
+  _settingsNavigationController.reset([settingsNavigationController retain]);
+}
+
+- (BOOL)startQRScannerAfterTabSwitcherDismissal {
+  return (experimental_flags::IsQRCodeReaderEnabled() &&
+          _startQRScannerAfterTabSwitcherDismissal);
+}
+
+- (void)setStartQRScannerAfterTabSwitcherDismissal:(BOOL)startQRScanner {
+  _startQRScannerAfterTabSwitcherDismissal = startQRScanner;
+}
+
+#pragma mark - StartupInformation implementation.
+
+- (FirstUserActionRecorder*)firstUserActionRecorder {
+  return _firstUserActionRecorder.get();
+}
+
+- (void)resetFirstUserActionRecorder {
+  _firstUserActionRecorder.reset();
+}
+
+- (void)expireFirstUserActionRecorderAfterDelay:(NSTimeInterval)delay {
+  [self performSelector:@selector(expireFirstUserActionRecorder)
+             withObject:nil
+             afterDelay:delay];
+}
+
+- (void)activateFirstUserActionRecorderWithBackgroundTime:
+    (NSTimeInterval)backgroundTime {
+  base::TimeDelta delta = base::TimeDelta::FromSeconds(backgroundTime);
+  _firstUserActionRecorder.reset(new FirstUserActionRecorder(delta));
+}
+
+- (void)stopChromeMain {
+  _chromeMain.reset();
+}
+
+- (BOOL)isTabSwitcherActive {
+  return _tabSwitcherIsActive;
+}
+
+#pragma mark - BrowserViewInformation implementation.
+
+- (void)haltAllTabs {
+  [_browserViewWrangler haltAllTabs];
+}
+
+- (void)cleanDeviceSharingManager {
+  [_browserViewWrangler cleanDeviceSharingManager];
+}
+
+#pragma mark - BrowsingDataRemovalControllerDelegate methods
+
+- (void)removeExternalFilesForBrowserState:
+            (ios::ChromeBrowserState*)browserState
+                         completionHandler:(ProceduralBlock)completionHandler {
+  // TODO(crbug.com/648940): Move this logic from BVC into
+  // BrowsingDataRemovalController thereby eliminating the need for
+  // BrowsingDataRemovalControllerDelegate. .
+  if (_mainBrowserState == browserState) {
+    [self.mainBVC removeExternalFilesImmediately:YES
+                               completionHandler:completionHandler];
+  } else if (completionHandler) {
+    dispatch_async(dispatch_get_main_queue(), completionHandler);
+  }
+}
+
+#pragma mark - Startup tasks
+
+- (void)sendQueuedFeedback {
+  [[DeferredInitializationRunner sharedInstance]
+      enqueueBlockNamed:kSendQueuedFeedback
+                  block:^{
+                    ios::GetChromeBrowserProvider()
+                        ->GetUserFeedbackProvider()
+                        ->Synchronize();
+                  }];
+}
+
+- (void)setInitialCookiesPolicy:(ios::ChromeBrowserState*)browserState {
+  DCHECK(browserState);
+  net::CookieStoreIOS::CookiePolicy policy = net::CookieStoreIOS::BLOCK;
+
+  auto settingsFactory =
+      ios::HostContentSettingsMapFactory::GetForBrowserState(browserState);
+  DCHECK(settingsFactory);
+  ContentSetting cookieSetting = settingsFactory->GetDefaultContentSetting(
+      CONTENT_SETTINGS_TYPE_COOKIES, nullptr);
+
+  if (!web::IsAcceptCookieControlSupported()) {
+    // Override the Accept Cookie policy as ALLOW is the only policy
+    // supported by //web.
+    policy = net::CookieStoreIOS::ALLOW;
+    if (cookieSetting == CONTENT_SETTING_BLOCK) {
+      settingsFactory->SetDefaultContentSetting(CONTENT_SETTINGS_TYPE_COOKIES,
+                                                CONTENT_SETTING_ALLOW);
+    }
+  } else {
+    switch (cookieSetting) {
+      case CONTENT_SETTING_ALLOW:
+        policy = net::CookieStoreIOS::ALLOW;
+        break;
+      case CONTENT_SETTING_BLOCK:
+        policy = net::CookieStoreIOS::BLOCK;
+        break;
+      default:
+        NOTREACHED() << "Unsupported cookie policy.";
+        break;
+    }
+  }
+
+  web::WebThread::PostTask(
+      web::WebThread::IO, FROM_HERE,
+      base::Bind(&net::CookieStoreIOS::SetCookiePolicy, policy));
+}
+
+- (void)orientationDidChange:(NSNotification*)notification {
+  breakpad_helper::SetCurrentOrientation(
+      [[UIApplication sharedApplication] statusBarOrientation],
+      [[UIDevice currentDevice] orientation]);
+}
+
+- (void)registerForOrientationChangeNotifications {
+  // Register to both device orientation and UI orientation did change
+  // notification as these two events may be triggered independantely.
+  [[NSNotificationCenter defaultCenter]
+      addObserver:self
+         selector:@selector(orientationDidChange:)
+             name:UIDeviceOrientationDidChangeNotification
+           object:nil];
+  [[NSNotificationCenter defaultCenter]
+      addObserver:self
+         selector:@selector(orientationDidChange:)
+             name:UIApplicationDidChangeStatusBarOrientationNotification
+           object:nil];
+}
+
+- (void)schedulePrefObserverInitialization {
+  [[DeferredInitializationRunner sharedInstance]
+      enqueueBlockNamed:kPrefObserverInit
+                  block:^{
+                    // Track changes to local state prefs.
+                    _localStatePrefObserverBridge.reset(
+                        new PrefObserverBridge(self));
+                    _localStatePrefChangeRegistrar.Init(
+                        GetApplicationContext()->GetLocalState());
+                    _localStatePrefObserverBridge->ObserveChangesForPreference(
+                        metrics::prefs::kMetricsReportingEnabled,
+                        &_localStatePrefChangeRegistrar);
+                    _localStatePrefObserverBridge->ObserveChangesForPreference(
+                        prefs::kMetricsReportingWifiOnly,
+                        &_localStatePrefChangeRegistrar);
+
+                    // Calls the onPreferenceChanged function in case there was
+                    // a
+                    // change to the observed preferences before the observer
+                    // bridge was set up.
+                    [self onPreferenceChanged:metrics::prefs::
+                                                  kMetricsReportingEnabled];
+                    [self onPreferenceChanged:prefs::kMetricsReportingWifiOnly];
+                  }];
+}
+
+- (void)scheduleCheckNativeApps {
+  void (^checkInstalledApps)(void) = ^{
+    [ios::GetChromeBrowserProvider()->GetNativeAppWhitelistManager()
+            checkInstalledApps];
+  };
+  [[DeferredInitializationRunner sharedInstance]
+      enqueueBlockNamed:kCheckNativeApps
+                  block:checkInstalledApps];
+}
+
+- (void)scheduleAppDistributionPings {
+  [[DeferredInitializationRunner sharedInstance]
+      enqueueBlockNamed:kSendInstallPingIfNecessary
+                  block:^{
+                    net::URLRequestContextGetter* context =
+                        _mainBrowserState->GetRequestContext();
+                    bool is_first_run = FirstRun::IsChromeFirstRun();
+                    ios::GetChromeBrowserProvider()
+                        ->GetAppDistributionProvider()
+                        ->ScheduleDistributionNotifications(context,
+                                                            is_first_run);
+                  }];
+}
+
+- (void)scheduleAuthenticationServiceNotification {
+  [[DeferredInitializationRunner sharedInstance]
+      enqueueBlockNamed:kAuthenticationServiceNotification
+                  block:^{
+                    DCHECK(_mainBrowserState);
+                    // Force an obvious initialization of the
+                    // AuthenticationService.
+                    // This is done for clarity purpose only, and should be
+                    // removed
+                    // alongside the delayed initialization. See
+                    // crbug.com/464306.
+                    AuthenticationServiceFactory::GetForBrowserState(
+                        _mainBrowserState);
+                    if (![self currentBrowserState]) {
+                      // Active browser state should have been set before
+                      // scheduling
+                      // any authentication service notification.
+                      NOTREACHED();
+                      return;
+                    }
+                    if ([SignedInAccountsViewController
+                            shouldBePresentedForBrowserState:
+                                [self currentBrowserState]]) {
+                      [self
+                          presentSignedInAccountsViewControllerForBrowserState:
+                              [self currentBrowserState]];
+                    }
+                  }];
+}
+
+- (void)scheduleStartupAttemptReset {
+  [[DeferredInitializationRunner sharedInstance]
+      enqueueBlockNamed:kStartupAttemptReset
+                  block:^{
+                    crash_util::ResetFailedStartupAttemptCount();
+                  }];
+}
+
+- (void)scheduleCrashReportCleanup {
+  [[DeferredInitializationRunner sharedInstance]
+      enqueueBlockNamed:kCleanupCrashReports
+                  block:^{
+                    breakpad_helper::CleanupCrashReports();
+                  }];
+}
+
+- (void)scheduleSnapshotPurge {
+  [[DeferredInitializationRunner sharedInstance]
+      enqueueBlockNamed:kPurgeSnapshots
+                  block:^{
+                    [self purgeSnapshots];
+                  }];
+}
+
+- (void)scheduleStartupCleanupTasks {
+  // Cleanup crash reports if this is the first run after an update.
+  if ([self isFirstLaunchAfterUpgrade]) {
+    [self scheduleCrashReportCleanup];
+  }
+
+  // ClearSessionCookies() is not synchronous.
+  if (cookie_util::ShouldClearSessionCookies()) {
+    cookie_util::ClearSessionCookies(
+        _mainBrowserState->GetOriginalChromeBrowserState());
+    if (![self.otrTabModel isEmpty]) {
+      cookie_util::ClearSessionCookies(
+          _mainBrowserState->GetOffTheRecordChromeBrowserState());
+    }
+  }
+
+  // If the user chooses to restore their session, some cached snapshots may
+  // be needed. Otherwise, purge the cached snapshots.
+  if (![self mustShowRestoreInfobar]) {
+    [self scheduleSnapshotPurge];
+  }
+}
+
+- (void)scheduleMemoryDebuggingTools {
+  if (experimental_flags::IsMemoryDebuggingEnabled()) {
+    [[DeferredInitializationRunner sharedInstance]
+        enqueueBlockNamed:kMemoryDebuggingToolsStartup
+                    block:^{
+                      _memoryDebuggerManager.reset(
+                          [[MemoryDebuggerManager alloc]
+                              initWithView:self.window
+                                     prefs:GetApplicationContext()
+                                               ->GetLocalState()]);
+                    }];
+  }
+}
+
+- (void)scheduleFreeMemoryMonitoring {
+  // TODO(crbug.com/649338): See if this method cannot call PostBlockingPoolTask
+  // directly instead of enqueueing a block.
+  [[DeferredInitializationRunner sharedInstance]
+      enqueueBlockNamed:kMemoryMonitoring
+                  block:^{
+                    web::WebThread::PostBlockingPoolTask(
+                        FROM_HERE,
+                        base::Bind(
+                            &ios_internal::AsynchronousFreeMemoryMonitor));
+                  }];
+}
+
+- (void)scheduleLowPriorityStartupTasks {
+  [_startupTasks initializeOmaha];
+  [_startupTasks registerForApplicationWillResignActiveNotification];
+  [self registerForOrientationChangeNotifications];
+
+  // Deferred tasks.
+  [self schedulePrefObserverInitialization];
+  [self scheduleMemoryDebuggingTools];
+  [_startupTasks scheduleDeferredBrowserStateInitialization:_mainBrowserState];
+  [self scheduleAuthenticationServiceNotification];
+  [self sendQueuedFeedback];
+  [self scheduleSpotlightResync];
+  [self scheduleDeleteDownloadsDirectory];
+  [self scheduleStartupAttemptReset];
+  [self scheduleFreeMemoryMonitoring];
+  [self scheduleAddApplicationShortcutItems];
+  [self scheduleAppDistributionPings];
+  [self scheduleCheckNativeApps];
+}
+
+- (void)scheduleTasksRequiringBVCWithBrowserState {
+  if (GetApplicationContext()->WasLastShutdownClean())
+    [self.mainBVC removeExternalFilesImmediately:NO completionHandler:nil];
+
+  [self scheduleShowPromo];
+}
+
+- (void)scheduleDeleteDownloadsDirectory {
+  [[DeferredInitializationRunner sharedInstance]
+      enqueueBlockNamed:kDeleteDownloads
+                  block:^{
+                    [DownloadManagerController clearDownloadsDirectory];
+                  }];
+}
+
+- (void)createSpotlightManager {
+  if (spotlight::IsSpotlightAvailable()) {
+    _spotlightManager.reset([[SpotlightManager
+        spotlightManagerWithBrowserState:_mainBrowserState] retain]);
+  }
+}
+
+- (void)scheduleSpotlightResync {
+  if (!_spotlightManager) {
+    return;
+  }
+  ProceduralBlock block = ^{
+    [_spotlightManager resyncIndex];
+  };
+  [[DeferredInitializationRunner sharedInstance]
+      enqueueBlockNamed:kStartSpotlightBookmarksIndexing
+                  block:block];
+}
+
+- (void)scheduleAddApplicationShortcutItems {
+  ProceduralBlock block = ^{
+    if (experimental_flags::IsQRCodeReaderEnabled()) {
+      UIApplicationShortcutItem* qrScannerShortcutItem = [[
+          [UIApplicationShortcutItem alloc]
+               initWithType:@"OpenQRScanner"
+             localizedTitle:l10n_util::GetNSString(
+                                IDS_IOS_APPLICATION_SHORTCUT_QR_SCANNER_TITLE)
+          localizedSubtitle:nil
+                       icon:[UIApplicationShortcutIcon
+                                iconWithTemplateImageName:
+                                    @"quick_action_qr_scanner"]
+                   userInfo:nil] autorelease];
+      // Note: The following only affects dynamic shortcut items defined
+      // programmatically, and not static shortcut items set in the Info.plist
+      // file.
+      [[UIApplication sharedApplication]
+          setShortcutItems:@[ qrScannerShortcutItem ]];
+    } else {
+      [[UIApplication sharedApplication] setShortcutItems:nil];
+    }
+  };
+
+  [[DeferredInitializationRunner sharedInstance]
+      enqueueBlockNamed:kAddApplicationShortcutItems
+                  block:block];
+}
+
+- (void)expireFirstUserActionRecorder {
+  // Clear out any scheduled calls to this method. For example, the app may have
+  // been backgrounded before the |kFirstUserActionTimeout| expired.
+  [NSObject
+      cancelPreviousPerformRequestsWithTarget:self
+                                     selector:@selector(
+                                                  expireFirstUserActionRecorder)
+                                       object:nil];
+
+  if (_firstUserActionRecorder) {
+    _firstUserActionRecorder->Expire();
+    _firstUserActionRecorder.reset();
+  }
+}
+
+- (BOOL)canLaunchInIncognito {
+  NSUserDefaults* standardDefaults = [NSUserDefaults standardUserDefaults];
+  if (![standardDefaults boolForKey:kIncognitoCurrentKey])
+    return NO;
+  // If the application crashed in incognito mode, don't stay in incognito
+  // mode, since the prompt to restore should happen in non-incognito
+  // context.
+  if ([self mustShowRestoreInfobar])
+    return NO;
+  // If there are no incognito tabs, then ensure the app starts in normal mode,
+  // since the UI isn't supposed to ever put the user in incognito mode without
+  // any incognito tabs.
+  return ![self.otrTabModel isEmpty];
+}
+
+- (void)createInitialUI:(ApplicationMode)launchMode {
+  DCHECK(_mainBrowserState);
+
+  // In order to correctly set the mode switch icon, we need to know how many
+  // tabs are in the other tab model. That means loading both models.  They
+  // may already be loaded.
+  // TODO(crbug.com/546203): Find a way to handle this that's closer to the
+  // point where it is necessary.
+  TabModel* mainTabModel = self.mainTabModel;
+  TabModel* otrTabModel = self.otrTabModel;
+
+  // MainCoordinator shouldn't have been initialized yet.
+  DCHECK(!_mainCoordinator);
+
+  // Enables UI initializations to query the keyWindow's size.
+  [self.window makeKeyAndVisible];
+
+  // Lazy init of mainCoordinator.
+  [self.mainCoordinator start];
+
+  // Decide if the First Run UI needs to run.
+  BOOL firstRun = (FirstRun::IsChromeFirstRun() ||
+                   experimental_flags::AlwaysDisplayFirstRun()) &&
+                  !tests_hook::DisableFirstRun();
+
+  ios::ChromeBrowserState* browserState =
+      (launchMode == ApplicationMode::INCOGNITO)
+          ? _mainBrowserState->GetOffTheRecordChromeBrowserState()
+          : _mainBrowserState;
+  [self changeStorageFromBrowserState:nullptr toBrowserState:browserState];
+
+  TabModel* tabModel;
+  if (launchMode == ApplicationMode::INCOGNITO) {
+    tabModel = otrTabModel;
+    self.currentBVC = self.otrBVC;
+  } else {
+    tabModel = mainTabModel;
+    self.currentBVC = self.mainBVC;
+  }
+  if (_tabSwitcherIsActive)
+    [self dismissTabSwitcherWithoutAnimationInModel:self.mainTabModel];
+  if (firstRun || [self shouldOpenNTPTabOnActivationOfTabModel:tabModel]) {
+    [self.currentBVC newTab:nil];
+  }
+
+  if (firstRun) {
+    [self showFirstRunUI];
+    // Do not ever show the 'restore' infobar during first run.
+    _restoreHelper.reset();
+  }
+}
+
+- (void)showFirstRunUI {
+  // Register for notification when First Run is completed.
+  // Some initializations are held back until First Run modal dialog
+  // is dismissed.
+  [[NSNotificationCenter defaultCenter]
+      addObserver:self
+         selector:@selector(handleFirstRunUIWillFinish)
+             name:kChromeFirstRunUIWillFinishNotification
+           object:nil];
+  [[NSNotificationCenter defaultCenter]
+      addObserver:self
+         selector:@selector(handleFirstRunUIDidFinish)
+             name:kChromeFirstRunUIDidFinishNotification
+           object:nil];
+
+  base::scoped_nsobject<WelcomeToChromeViewController> welcomeToChrome(
+      [[WelcomeToChromeViewController alloc]
+          initWithBrowserState:_mainBrowserState
+                      tabModel:self.mainTabModel]);
+  base::scoped_nsobject<UINavigationController> navController(
+      [[OrientationLimitingNavigationController alloc]
+          initWithRootViewController:welcomeToChrome]);
+  [navController setModalTransitionStyle:UIModalTransitionStyleCrossDissolve];
+  CGRect appFrame = [[UIScreen mainScreen] bounds];
+  [[navController view] setFrame:appFrame];
+  _isPresentingFirstRunUI = YES;
+  [self.mainBVC presentViewController:navController animated:NO completion:nil];
+}
+
+- (void)crashIfRequested {
+  if (experimental_flags::IsStartupCrashEnabled()) {
+    // Flush out the value cached for
+    // ios_internal::breakpad::SetUploadingEnabled().
+    [[NSUserDefaults standardUserDefaults] synchronize];
+
+    int* x = NULL;
+    *x = 0;
+  }
+}
+
+#pragma mark - Promo support
+
+- (void)scheduleShowPromo {
+  // Don't show promos if first run is shown.  (Note:  This flag is only YES
+  // while the first run UI is visible.  However, as this function is called
+  // immediately after the UI is shown, it's a safe check.)
+  if (_isPresentingFirstRunUI)
+    return;
+  // Don't show promos in Incognito mode.
+  if (self.currentBVC == self.otrBVC)
+    return;
+  // Don't show promos if the app was launched from a URL.
+  if (_startupParameters)
+    return;
+
+  // This array should contain Class objects - one for each promo class.
+  // New PromoViewController subclasses should be added here.
+  // Note that ordering matters -- only the first promo in the array that
+  // returns true to +shouldBePresentedForProfile: will be shown.
+  // TODO(crbug.com/516154): Now that there's only one promo class, this
+  // implementation is overkill.
+  NSArray* possiblePromos = @[ [SigninPromoViewController class] ];
+  for (id promoController in possiblePromos) {
+    Class promoClass = (Class)promoController;
+    DCHECK(class_isMetaClass(object_getClass(promoClass)));
+    DCHECK(class_getClassMethod(object_getClass(promoClass),
+                                @selector(shouldBePresentedForBrowserState:)));
+    if ([promoClass shouldBePresentedForBrowserState:_mainBrowserState]) {
+      UIViewController* promoController =
+          [promoClass controllerToPresentForBrowserState:_mainBrowserState];
+
+      dispatch_after(
+          dispatch_time(DISPATCH_TIME_NOW,
+                        (int64_t)(kDisplayPromoDelay * NSEC_PER_SEC)),
+          dispatch_get_main_queue(), ^{
+            [self showPromo:promoController];
+          });
+
+      break;
+    }
+  }
+}
+
+- (void)showPromo:(UIViewController*)promo {
+  // Make sure we have the BVC here with a valid profile.
+  DCHECK([self.currentBVC browserState]);
+
+  base::scoped_nsobject<OrientationLimitingNavigationController> navController(
+      [[OrientationLimitingNavigationController alloc]
+          initWithRootViewController:promo]);
+
+  // Avoid presenting the promo if the current device orientation is not
+  // supported. The promo will be presented at a later moment, when the device
+  // orientation is supported.
+  UIInterfaceOrientation orientation =
+      [UIApplication sharedApplication].statusBarOrientation;
+  NSUInteger supportedOrientationsMask =
+      [navController supportedInterfaceOrientations];
+  if (!((1 << orientation) & supportedOrientationsMask))
+    return;
+
+  [navController setModalTransitionStyle:[promo modalTransitionStyle]];
+  [navController setNavigationBarHidden:YES];
+  [[navController view] setFrame:[[UIScreen mainScreen] bounds]];
+
+  [self.mainBVC presentViewController:navController
+                             animated:YES
+                           completion:nil];
+}
+
+#pragma mark - chromeExecuteCommand
+
+- (IBAction)chromeExecuteCommand:(id)sender {
+  NSInteger command = [sender tag];
+
+  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 =
+          base::mac::ObjCCastStrict<ShowSigninCommand>(sender);
+      if (command.operation == AUTHENTICATION_OPERATION_DISMISS) {
+        [self dismissSigninInteractionController];
+      } else {
+        [self showSignInWithOperation:command.operation
+                    signInAccessPoint:command.signInAccessPoint
+                             callback:command.callback];
+      }
+      break;
+    }
+    case IDC_SHOW_ACCOUNTS_SETTINGS: {
+      [self showAccountsSettings];
+      break;
+    }
+    case IDC_SHOW_SYNC_SETTINGS:
+      [self showSyncSettings];
+      break;
+    case IDC_SHOW_SYNC_PASSPHRASE_SETTINGS:
+      [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) {
+        [self showTabSwitcher];
+        _isProcessingTabSwitcherCommand = YES;
+        dispatch_after(dispatch_time(DISPATCH_TIME_NOW,
+                                     kExpectedTransitionDurationInNanoSeconds),
+                       dispatch_get_main_queue(), ^{
+                         _isProcessingTabSwitcherCommand = NO;
+                       });
+      }
+      break;
+    case IDC_PRELOAD_VOICE_SEARCH:
+      [self.currentBVC chromeExecuteCommand:sender];
+      break;
+    case IDC_VOICE_SEARCH:
+      if (!_isProcessingTabSwitcherCommand) {
+        [self startVoiceSearch];
+        _isProcessingVoiceSearchCommand = YES;
+        dispatch_after(dispatch_time(DISPATCH_TIME_NOW,
+                                     kExpectedTransitionDurationInNanoSeconds),
+                       dispatch_get_main_queue(), ^{
+                         _isProcessingVoiceSearchCommand = NO;
+                       });
+      }
+      break;
+    case IDC_CLEAR_BROWSING_DATA_IOS: {
+      // Clear both the main browser state and the associated incognito
+      // browser state.
+      ClearBrowsingDataCommand* command =
+          base::mac::ObjCCastStrict<ClearBrowsingDataCommand>(sender);
+      ios::ChromeBrowserState* browserState =
+          [command browserState]->GetOriginalChromeBrowserState();
+      int mask = [command mask];
+      browsing_data::TimePeriod timePeriod = [command timePeriod];
+      [self removeBrowsingDataFromBrowserState:browserState
+                                          mask:mask
+                                    timePeriod:timePeriod
+                             completionHandler:nil];
+
+      if (mask & IOSChromeBrowsingDataRemover::REMOVE_COOKIES) {
+        base::Time beginDeleteTime =
+            browsing_data::CalculateBeginDeleteTime(timePeriod);
+        [ChromeWebViewFactory clearExternalCookies:browserState
+                                          fromTime:beginDeleteTime
+                                            toTime:base::Time::Max()];
+      }
+      break;
+    }
+    case IDC_RESET_ALL_WEBVIEWS:
+      [self.currentBVC resetAllWebViews];
+      break;
+    case IDC_SHOW_GOOGLE_APPS_SETTINGS:
+      [self showNativeAppsSettings];
+      break;
+    case IDC_SHOW_CLEAR_BROWSING_DATA_SETTINGS:
+      [self showClearBrowsingDataSettingsController];
+      break;
+    case IDC_SHOW_CONTEXTUAL_SEARCH_SETTINGS:
+      [self showContextualSearchSettingsController];
+      break;
+    case IDC_CLOSE_MODALS:
+      [self dismissModalDialogsWithCompletion:nil];
+      break;
+    case IDC_SHOW_ADD_ACCOUNT:
+      [self showAddAccount];
+      break;
+    default:
+      // Unknown commands get dropped with a warning.
+      NOTREACHED() << "Unknown command id " << command;
+      LOG(WARNING) << "Unknown command id " << command;
+      break;
+  }
+}
+
+#pragma mark - chromeExecuteCommand helpers
+
+- (void)openUrl:(OpenUrlCommand*)command {
+  if ([command fromChrome]) {
+    [self dismissModalsAndOpenSelectedTabInMode:ApplicationMode::NORMAL
+                                        withURL:[command url]
+                                     transition:ui::PAGE_TRANSITION_TYPED
+                                     completion:nil];
+  } else {
+    [self dismissModalDialogsWithCompletion:^{
+      self.currentBVC = [command inIncognito] ? self.otrBVC : self.mainBVC;
+      [self.currentBVC webPageOrderedOpen:[command url]
+                                 referrer:[command referrer]
+                               windowName:[command windowName]
+                             inBackground:[command inBackground]
+                                 appendTo:[command appendTo]];
+    }];
+  }
+}
+
+- (void)openUrlFromSettings:(OpenUrlCommand*)command {
+  DCHECK([command fromChrome]);
+  ProceduralBlock completion = ^{
+    [self dismissModalsAndOpenSelectedTabInMode:ApplicationMode::NORMAL
+                                        withURL:[command url]
+                                     transition:ui::PAGE_TRANSITION_TYPED
+                                     completion:nil];
+  };
+  [self closeSettingsAnimated:YES completion:completion];
+}
+
+- (void)startVoiceSearch {
+  // If the background (non-current) BVC is playing TTS audio, call
+  // -startVoiceSearch on it to stop the TTS.
+  BrowserViewController* backgroundBVC =
+      self.mainBVC == self.currentBVC ? self.otrBVC : self.mainBVC;
+  if (backgroundBVC.playingTTS)
+    [backgroundBVC startVoiceSearch];
+  else
+    [self.currentBVC startVoiceSearch];
+}
+
+#pragma mark - Preferences Management
+
+- (void)onPreferenceChanged:(const std::string&)preferenceName {
+  // Turn on or off metrics & crash reporting when either preference changes.
+  if (preferenceName == metrics::prefs::kMetricsReportingEnabled ||
+      preferenceName == prefs::kMetricsReportingWifiOnly) {
+    [_metricsMediator updateMetricsStateBasedOnPrefsUserTriggered:YES];
+  }
+}
+
+#pragma mark - BrowserViewInformation properties
+
+- (BrowserViewController*)mainBVC {
+  DCHECK(_browserViewWrangler);
+  return [_browserViewWrangler mainBVC];
+}
+
+- (void)setMainBVC:(BrowserViewController*)mainBVC {
+  DCHECK(_browserViewWrangler);
+  [_browserViewWrangler setMainBVC:mainBVC];
+}
+
+- (TabModel*)mainTabModel {
+  DCHECK(_browserViewWrangler);
+  return [_browserViewWrangler mainTabModel];
+}
+
+- (void)setMainTabModel:(TabModel*)mainTabModel {
+  DCHECK(_browserViewWrangler);
+  [_browserViewWrangler setMainTabModel:mainTabModel];
+}
+
+- (BrowserViewController*)otrBVC {
+  DCHECK(_browserViewWrangler);
+  return [_browserViewWrangler otrBVC];
+}
+
+- (void)setOtrBVC:(BrowserViewController*)otrBVC {
+  DCHECK(_browserViewWrangler);
+  [_browserViewWrangler setOtrBVC:otrBVC];
+}
+
+- (TabModel*)otrTabModel {
+  DCHECK(_browserViewWrangler);
+  return [_browserViewWrangler otrTabModel];
+}
+
+- (void)setOtrTabModel:(TabModel*)otrTabModel {
+  DCHECK(_browserViewWrangler);
+  [_browserViewWrangler setOtrTabModel:otrTabModel];
+}
+
+- (BrowserViewController*)currentBVC {
+  DCHECK(_browserViewWrangler);
+  return [_browserViewWrangler currentBVC];
+}
+
+// Note that the current tab of |bvc| will normally be reloaded by this method.
+// If a new tab is about to be added, call expectNewForegroundTab on the BVC
+// first to avoid extra work and possible page load side-effects for the tab
+// being replaced.
+- (void)setCurrentBVC:(BrowserViewController*)bvc {
+  DCHECK(bvc != nil);
+  if (self.currentBVC == bvc)
+    return;
+
+  DCHECK(_browserViewWrangler);
+  [_browserViewWrangler setCurrentBVC:bvc storageSwitcher:self];
+
+  if (!_dismissingStackView)
+    [self displayCurrentBVC];
+
+  // Tell the BVC that was made current that it can use the web.
+  [self activateCurrentBVC];
+}
+
+#pragma mark - Tab closure handlers
+
+- (void)lastIncognitoTabClosed {
+  DCHECK(_mainBrowserState->HasOffTheRecordChromeBrowserState());
+  [self clearIOSSpecificIncognitoData];
+  UnSynchronizeCookieStore(
+      _mainBrowserState->GetOffTheRecordChromeBrowserState());
+
+  // OffTheRecordProfileIOData cannot be deleted before all the requests are
+  // deleted. All of the request trackers associated with the closed OTR tabs
+  // will have posted CancelRequest calls to the IO thread by now; this just
+  // waits for those calls to run before calling |deleteIncognitoBrowserState|.
+  web::RequestTrackerImpl::RunAfterRequestsCancel(base::BindBlock(^{
+    [self deleteIncognitoBrowserState];
+  }));
+
+  // a) The first condition can happen when the last incognito 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 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];
+    }
+  } 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];
+  }
+}
+
+#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
+  // incognito.
+  [standardDefaults synchronize];
+}
+
+- (void)changeStorageFromBrowserState:(ios::ChromeBrowserState*)oldState
+                       toBrowserState:(ios::ChromeBrowserState*)newState {
+  ApplicationMode mode = newState->IsOffTheRecord() ? ApplicationMode::INCOGNITO
+                                                    : ApplicationMode::NORMAL;
+  [self switchGlobalStateToMode:mode];
+}
+
+// Set |bvc| as the current BVC and then creates a new tab.
+- (void)createNewTabInBVC:(BrowserViewController*)bvc sender:(id)sender {
+  DCHECK(bvc);
+  [bvc expectNewForegroundTab];
+  self.currentBVC = bvc;
+  [self.currentBVC newTab:sender];
+}
+
+- (void)displayCurrentBVC {
+  self.mainViewController.activeViewController = self.currentBVC;
+}
+
+- (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];
+
+  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()) {
+    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.
+    [[_tabSwitcherController view] setUserInteractionEnabled:YES];
+    self.mainViewController.activeViewController = _tabSwitcherController;
+    [_tabSwitcherController showWithSelectedTabAnimation];
+  }
+}
+
+- (BOOL)shouldOpenNTPTabOnActivationOfTabModel:(TabModel*)tabModel {
+  if (_settingsNavigationController) {
+    return false;
+  }
+  if (_tabSwitcherIsActive) {
+    // Only attempt to dismiss the tab switcher and open a new tab if:
+    // - there are no tabs open in either tab model, and
+    // - the tab switcher controller is not directly or indirectly presenting
+    // another view controller.
+    if (![self.mainTabModel isEmpty] || ![self.otrTabModel isEmpty])
+      return NO;
+
+    UIViewController* viewController = [self topPresentedViewController];
+    while (viewController) {
+      if ([viewController.presentingViewController
+              isEqual:_tabSwitcherController]) {
+        return NO;
+      }
+      viewController = viewController.presentingViewController;
+    }
+    return YES;
+  }
+  return ![tabModel count] && [tabModel browserState] &&
+         ![tabModel browserState]->IsOffTheRecord();
+}
+
+#pragma mark - TabSwitching implementation.
+
+- (BOOL)openNewTabFromTabSwitcher {
+  if (!_tabSwitcherController)
+    return NO;
+
+  [_tabSwitcherController
+      dismissWithNewTabAnimationToModel:self.mainTabModel
+                                withURL:GURL(kChromeUINewTabURL)
+                                atIndex:NSNotFound
+                             transition:ui::PAGE_TRANSITION_TYPED];
+  return YES;
+}
+
+- (void)dismissTabSwitcherWithoutAnimationInModel:(TabModel*)tabModel {
+  DCHECK(_tabSwitcherIsActive);
+  DCHECK(!_dismissingStackView);
+  if ([_tabSwitcherController
+          respondsToSelector:@selector(tabSwitcherDismissWithModel:
+                                                          animated:)]) {
+    [self dismissModalDialogsWithCompletion:nil];
+    [_tabSwitcherController tabSwitcherDismissWithModel:tabModel animated:NO];
+  } else {
+    [self beginDismissingStackViewWithCurrentModel:tabModel];
+    [self finishDismissingStackView];
+  }
+}
+
+#pragma mark - TabSwitcherDelegate Implementation
+
+- (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;
+  }
+
+  _modeToDisplayOnStackViewDismissal = StackViewDismissalMode::NONE;
+
+  // Displaying the current BVC dismisses the stack view.
+  [self displayCurrentBVC];
+
+  // Start Voice Search or QR Scanner now that they can be presented from the
+  // current BVC.
+  if (_startVoiceSearchAfterTabSwitcherDismissal) {
+    _startVoiceSearchAfterTabSwitcherDismissal = NO;
+    [self.currentBVC startVoiceSearch];
+  } else if ([self startQRScannerAfterTabSwitcherDismissal]) {
+    [self setStartQRScannerAfterTabSwitcherDismissal:NO];
+    [self.currentBVC showQRScanner];
+  }
+
+  [_tabSwitcherController setDelegate:nil];
+
+  _tabSwitcherIsActive = NO;
+  _dismissingStackView = NO;
+}
+
+- (void)tabSwitcherPresentationTransitionDidEnd:(id<TabSwitcher>)tabSwitcher {
+}
+
+- (id<ToolbarOwner>)tabSwitcherTransitionToolbarOwner {
+  // Request the view to ensure that the view has been loaded and initialized,
+  // since it may never have been loaded (or have been swapped out).
+  [self.currentBVC ensureViewCreated];
+  return self.currentBVC;
+}
+
+#pragma mark - Browsing data clearing
+
+- (void)removeBrowsingDataFromBrowserState:
+            (ios::ChromeBrowserState*)browserState
+                                      mask:(int)mask
+                                timePeriod:(browsing_data::TimePeriod)timePeriod
+                         completionHandler:(ProceduralBlock)completionHandler {
+  // TODO(crbug.com/632772): Remove web usage disabling once
+  // https://bugs.webkit.org/show_bug.cgi?id=149079 has been fixed.
+  if (browserState == self.currentBrowserState &&
+      (mask & IOSChromeBrowsingDataRemover::REMOVE_COOKIES)) {
+    [self setWebUsageEnabled:NO];
+  }
+
+  ProceduralBlock browsingDataRemoved = ^{
+    [self setWebUsageEnabled:YES];
+    if (completionHandler) {
+      completionHandler();
+    }
+  };
+  [self.browsingDataRemovalController
+      removeBrowsingDataFromBrowserState:browserState
+                                    mask:mask
+                              timePeriod:timePeriod
+                       completionHandler:browsingDataRemoved];
+}
+
+#pragma mark - Navigation Controllers
+
+- (void)presentSignedInAccountsViewControllerForBrowserState:
+    (ios::ChromeBrowserState*)browserState {
+  base::scoped_nsobject<UIViewController> accountsViewController(
+      [[SignedInAccountsViewController alloc]
+          initWithBrowserState:browserState]);
+  [[self topPresentedViewController]
+      presentViewController:accountsViewController
+                   animated:YES
+                 completion:nil];
+}
+
+- (void)showSettings {
+  if (_settingsNavigationController)
+    return;
+  [[DeferredInitializationRunner sharedInstance]
+      runBlockIfNecessary:kPrefObserverInit];
+  DCHECK(_localStatePrefObserverBridge);
+  _settingsNavigationController.reset([SettingsNavigationController
+      newSettingsMainControllerWithMainBrowserState:_mainBrowserState
+                                currentBrowserState:self.currentBrowserState
+                                           delegate:self]);
+  [[self topPresentedViewController]
+      presentViewController:_settingsNavigationController
+                   animated:YES
+                 completion:nil];
+}
+
+- (void)showAccountsSettings {
+  if (_settingsNavigationController)
+    return;
+  if ([self currentBrowserState]->IsOffTheRecord()) {
+    NOTREACHED();
+    return;
+  }
+  _settingsNavigationController.reset([SettingsNavigationController
+      newAccountsController:self.currentBrowserState
+                   delegate:self]);
+  [[self topPresentedViewController]
+      presentViewController:_settingsNavigationController
+                   animated:YES
+                 completion:nil];
+}
+
+- (void)showSyncSettings {
+  if (_settingsNavigationController)
+    return;
+  _settingsNavigationController.reset([SettingsNavigationController
+           newSyncController:_mainBrowserState
+      allowSwitchSyncAccount:YES
+                    delegate:self]);
+  [[self topPresentedViewController]
+      presentViewController:_settingsNavigationController
+                   animated:YES
+                 completion:nil];
+}
+
+- (void)showSavePasswordsSettings {
+  if (_settingsNavigationController)
+    return;
+  _settingsNavigationController.reset([SettingsNavigationController
+      newSavePasswordsController:_mainBrowserState
+                        delegate:self]);
+  [[self topPresentedViewController]
+      presentViewController:_settingsNavigationController
+                   animated:YES
+                 completion:nil];
+}
+
+- (void)showReportAnIssue {
+  if (_settingsNavigationController)
+    return;
+  _settingsNavigationController.reset([SettingsNavigationController
+      newUserFeedbackController:_mainBrowserState
+                       delegate:self
+             feedbackDataSource:self]);
+  [[self topPresentedViewController]
+      presentViewController:_settingsNavigationController
+                   animated:YES
+                 completion:nil];
+}
+
+- (void)showSyncEncryptionPassphrase {
+  if (_settingsNavigationController)
+    return;
+  _settingsNavigationController.reset([SettingsNavigationController
+      newSyncEncryptionPassphraseController:_mainBrowserState
+                                   delegate:self]);
+  [[self topPresentedViewController]
+      presentViewController:_settingsNavigationController
+                   animated:YES
+                 completion:nil];
+}
+
+- (void)showClearBrowsingDataSettingsController {
+  if (_settingsNavigationController)
+    return;
+  _settingsNavigationController.reset([SettingsNavigationController
+      newClearBrowsingDataController:_mainBrowserState
+                            delegate:self]);
+  [[self topPresentedViewController]
+      presentViewController:_settingsNavigationController
+                   animated:YES
+                 completion:nil];
+}
+
+- (void)showContextualSearchSettingsController {
+  if (_settingsNavigationController)
+    return;
+  _settingsNavigationController.reset([SettingsNavigationController
+      newContextualSearchController:_mainBrowserState
+                           delegate:self]);
+  [[self topPresentedViewController]
+      presentViewController:_settingsNavigationController
+                   animated:YES
+                 completion:nil];
+}
+
+- (void)showSignInWithOperation:(AuthenticationOperation)operation
+              signInAccessPoint:(signin_metrics::AccessPoint)signInAccessPoint
+                       callback:(ShowSigninCommandCompletionCallback)callback {
+  DCHECK_NE(AUTHENTICATION_OPERATION_DISMISS, operation);
+
+  if (_signinInteractionController) {
+    // Avoid showing the sign in screen if there is already a sign-in operation
+    // in progress.
+    return;
+  }
+
+  BOOL areSettingsPresented = _settingsNavigationController != NULL;
+  _signinInteractionController.reset([[SigninInteractionController alloc]
+          initWithBrowserState:_mainBrowserState
+      presentingViewController:[self topPresentedViewController]
+         isPresentedOnSettings:areSettingsPresented
+             signInAccessPoint:signInAccessPoint]);
+
+  signin_ui::CompletionCallback completion = ^(BOOL success) {
+    _signinInteractionController.reset();
+    if (callback)
+      callback(success);
+  };
+
+  switch (operation) {
+    case AUTHENTICATION_OPERATION_DISMISS:
+      // Special case handled above.
+      NOTREACHED();
+      break;
+    case AUTHENTICATION_OPERATION_REAUTHENTICATE:
+      [_signinInteractionController
+          reAuthenticateWithCompletion:completion
+                        viewController:self.mainViewController];
+      break;
+    case AUTHENTICATION_OPERATION_SIGNIN:
+      [_signinInteractionController
+          signInWithCompletion:completion
+                viewController:self.mainViewController];
+      break;
+  }
+}
+
+- (void)showAddAccount {
+  if (_signinInteractionController) {
+    // Avoid showing the sign in screen if there is already a sign-in operation
+    // in progress.
+    return;
+  }
+
+  BOOL areSettingsPresented = _settingsNavigationController != NULL;
+  _signinInteractionController.reset([[SigninInteractionController alloc]
+          initWithBrowserState:_mainBrowserState
+      presentingViewController:[self topPresentedViewController]
+         isPresentedOnSettings:areSettingsPresented
+             signInAccessPoint:signin_metrics::AccessPoint::
+                                   ACCESS_POINT_UNKNOWN]);
+
+  [_signinInteractionController
+      addAccountWithCompletion:^(BOOL success) {
+        _signinInteractionController.reset();
+      }
+                viewController:self.mainViewController];
+}
+
+- (void)showHistory {
+  _historyPanelViewController.reset([[HistoryPanelViewController
+      controllerToPresentForBrowserState:_mainBrowserState
+                                  loader:self.currentBVC] retain]);
+  [self.currentBVC presentViewController:_historyPanelViewController
+                                animated:YES
+                              completion:nil];
+}
+
+- (void)dismissSigninInteractionController {
+  // The sign-in interaction controller is destroyed as a result of calling
+  // |cancelAndDismiss|. Destroying it here may lead to a missing call of the
+  // |ShowSigninCommandCompletionCallback| passed when starting a show sign-in
+  // operation.
+  [_signinInteractionController cancelAndDismiss];
+}
+
+- (ShowSigninCommandCompletionCallback)successfulSigninCompletion:
+    (ProceduralBlock)callback {
+  return [[^(BOOL successful) {
+    ios::ChromeBrowserState* browserState = [self currentBrowserState];
+    if (browserState->IsOffTheRecord()) {
+      NOTREACHED()
+          << "Ignore call to |handleSignInFinished| when in incognito.";
+      return;
+    }
+    DCHECK_EQ(self.mainBVC, self.currentBVC);
+    SigninManager* signinManager =
+        ios::SigninManagerFactory::GetForBrowserState(browserState);
+    if (signinManager->IsAuthenticated())
+      callback();
+  } copy] autorelease];
+}
+
+- (void)showNativeAppsSettings {
+  if (_settingsNavigationController)
+    return;
+  _settingsNavigationController.reset([SettingsNavigationController
+      newNativeAppsController:_mainBrowserState
+                     delegate:self]);
+  [[self topPresentedViewController]
+      presentViewController:_settingsNavigationController
+                   animated:YES
+                 completion:nil];
+}
+
+- (void)closeSettingsAnimated:(BOOL)animated
+                   completion:(ProceduralBlock)completion {
+  DCHECK(_settingsNavigationController);
+  [_settingsNavigationController settingsWillBeDismissed];
+  UIViewController* presentingViewController =
+      [_settingsNavigationController presentingViewController];
+  DCHECK(presentingViewController);
+  [presentingViewController dismissViewControllerAnimated:animated
+                                               completion:^{
+                                                 if (completion)
+                                                   completion();
+                                               }];
+  _settingsNavigationController.reset();
+}
+
+#pragma mark - TabModelObserver
+
+// Called when the number of tabs changes. Triggers the switcher view when
+// the last tab is closed on a device that uses the switcher.
+- (void)tabModelDidChangeTabCount:(TabModel*)notifiedTabModel {
+  TabModel* currentTabModel = [self currentTabModel];
+  // Do nothing on initialization.
+  if (!currentTabModel)
+    return;
+
+  if (notifiedTabModel.count == 0U) {
+    if ([notifiedTabModel isOffTheRecord]) {
+      [self lastIncognitoTabClosed];
+    } else {
+      [self lastRegularTabClosed];
+    }
+  }
+}
+
+#pragma mark - Tab opening utility methods.
+
+- (Tab*)openOrReuseTabInMode:(ApplicationMode)targetMode
+                     withURL:(const GURL&)url
+                  transition:(ui::PageTransition)transition {
+  BrowserViewController* targetBVC =
+      targetMode == ApplicationMode::NORMAL ? self.mainBVC : self.otrBVC;
+  GURL currentURL;
+
+  Tab* currentTabInTargetBVC = [[targetBVC tabModel] currentTab];
+  if (currentTabInTargetBVC)
+    currentURL = [currentTabInTargetBVC url];
+
+  if (!(currentTabInTargetBVC && IsURLNtp(currentURL))) {
+    return [targetBVC addSelectedTabWithURL:url
+                                    atIndex:NSNotFound
+                                 transition:transition];
+  }
+
+  Tab* newTab = currentTabInTargetBVC;
+  // Don't call loadWithParams for chrome://newtab, it's already loaded.
+  if (!(IsURLNtp(url))) {
+    web::NavigationManager::WebLoadParams params(url);
+    [[newTab webController] loadWithParams:params];
+  }
+  return newTab;
+}
+
+- (Tab*)openSelectedTabInMode:(ApplicationMode)targetMode
+                      withURL:(const GURL&)url
+                   transition:(ui::PageTransition)transition {
+  BrowserViewController* targetBVC =
+      targetMode == ApplicationMode::NORMAL ? self.mainBVC : self.otrBVC;
+  NSUInteger tabIndex = NSNotFound;
+
+  Tab* tab = nil;
+  if (_tabSwitcherIsActive) {
+    // If the stack view is already being dismissed, simply add the tab and
+    // note that when the stack view finishes dismissing, the current BVC should
+    // be switched to be the main BVC if necessary.
+    if (_dismissingStackView) {
+      _modeToDisplayOnStackViewDismissal =
+          targetMode == ApplicationMode::NORMAL
+              ? StackViewDismissalMode::NORMAL
+              : StackViewDismissalMode::INCOGNITO;
+      tab = [targetBVC addSelectedTabWithURL:url
+                                     atIndex:tabIndex
+                                  transition:transition];
+    } else {
+      tab = [_tabSwitcherController
+          dismissWithNewTabAnimationToModel:targetBVC.tabModel
+                                    withURL:url
+                                    atIndex:tabIndex
+                                 transition:transition];
+    }
+  } else {
+    if (!self.currentBVC.presentedViewController) {
+      [targetBVC expectNewForegroundTab];
+    }
+    self.currentBVC = targetBVC;
+    tab = [self openOrReuseTabInMode:targetMode
+                             withURL:url
+                          transition:transition];
+  }
+
+  if ([_startupParameters launchVoiceSearch]) {
+    if (_tabSwitcherIsActive || _dismissingStackView) {
+      // Since VoiceSearch is presented by the BVC, it must be started after the
+      // Tab Switcher dismissal completes and the BVC's view is in the
+      // hiararchy.
+      _startVoiceSearchAfterTabSwitcherDismissal = YES;
+    } else {
+      // When starting the application from the Notification center,
+      // ApplicationWillResignActive is sent just after startup.
+      // If the voice search is triggered synchronously, it is immediately
+      // dismissed. Start it asynchronously instead.
+      dispatch_async(dispatch_get_main_queue(), ^{
+        [self startVoiceSearch];
+      });
+    }
+  } else if ([_startupParameters launchQRScanner]) {
+    if (_tabSwitcherIsActive || _dismissingStackView) {
+      // QR Scanner is presented by the BVC, similarly to VoiceSearch. It must
+      // also be started after the BVC's view is in the hierarchy.
+      [self setStartQRScannerAfterTabSwitcherDismissal:YES];
+    } else {
+      // Start the QR Scanner asynchronously to prevent the application from
+      // dismissing the modal view if QR Scanner is started from the
+      // Notification center.
+      dispatch_async(dispatch_get_main_queue(), ^{
+        [self.currentBVC showQRScanner];
+      });
+    }
+  }
+
+  if (_restoreHelper) {
+    // Now that all the operations on the tabs have been done, display the
+    // restore infobar if needed.
+    dispatch_async(dispatch_get_main_queue(), ^{
+      [_restoreHelper showRestoreIfNeeded:[self currentTabModel]];
+      _restoreHelper.reset();
+    });
+  }
+
+  return tab;
+}
+
+- (void)dismissModalDialogsWithCompletion:(ProceduralBlock)completion {
+  // Immediately hide modals from the provider (alert views, action sheets,
+  // popovers). They will be ultimately dismissed by their owners, but at least,
+  // they are not visible.
+  ios::GetChromeBrowserProvider()->HideModalViewStack();
+
+  // ChromeIdentityService is responsible for the dialogs displayed by the
+  // services it wraps.
+  ios::GetChromeBrowserProvider()->GetChromeIdentityService()->DismissDialogs();
+
+  // Cancel interaction with SSO.
+  // First, cancel the signin interaction.
+  [_signinInteractionController cancel];
+
+  // Then, depending on what the SSO view controller is presented on, dismiss
+  // it.
+  ProceduralBlock completionWithBVC = ^{
+    // This will dismiss the SSO view controller.
+    [self.currentBVC clearPresentedStateWithCompletion:completion];
+  };
+  ProceduralBlock completionWithoutBVC = ^{
+    // This will dismiss the SSO view controller.
+    [self dismissSigninInteractionController];
+    if (completion)
+      completion();
+  };
+
+  // As a top level rule, if the settings are showing, they need to be
+  // dismissed. Then, based on whether the BVC is present or not, a different
+  // completion callback is called.
+  if (self.currentBVC && _settingsNavigationController) {
+    // In this case, the settings are up and the BVC is showing. Close the
+    // settings then call the BVC completion.
+    [self closeSettingsAnimated:NO completion:completionWithBVC];
+  } else if (_settingsNavigationController) {
+    // In this case, the settings are up but the BVC is not showing. Close the
+    // settings then call the no-BVC completion.
+    [self closeSettingsAnimated:NO completion:completionWithoutBVC];
+  } else if (self.currentBVC) {
+    // In this case, the settings are not shown but the BVC is showing. Call the
+    // BVC completion.
+    completionWithBVC();
+  } else {
+    // In this case, neither the settings nor the BVC are shown. Call the no-BVC
+    // completion.
+    completionWithoutBVC();
+  }
+
+  // Verify that no modal views are left presented.
+  ios::GetChromeBrowserProvider()->LogIfModalViewsArePresented();
+}
+
+// iOS does not guarantee the order in which the observers are notified by
+// the notification center. There are different parts of the application that
+// register for UIApplication notifications so recording them in order to
+// measure the performance of the app being moved to the foreground / background
+// is not reliable. Instead we prefer using designated notifications that are
+// posted to the observers on the first available run loop cycle, which
+// guarantees that they are delivered to the observer only after UIApplication
+// notifications have been treated.
+- (void)postNotificationOnNextRunLoopCycle:(NSString*)notificationName {
+  dispatch_async(dispatch_get_main_queue(), ^{
+    [[NSNotificationCenter defaultCenter] postNotificationName:notificationName
+                                                        object:self];
+  });
+}
+
+- (bool)mustShowRestoreInfobar {
+  if ([self isFirstLaunchAfterUpgrade])
+    return false;
+  return !GetApplicationContext()->WasLastShutdownClean();
+}
+
+- (NSMutableSet*)liveSessionsForTabModel:(TabModel*)tabModel {
+  NSMutableSet* result = [NSMutableSet setWithCapacity:[tabModel count]];
+  for (size_t i = 0; i < [tabModel count]; ++i)
+    [result addObject:[[tabModel tabAtIndex:i] currentSessionID]];
+  return result;
+}
+
+- (void)purgeSnapshots {
+  NSMutableSet* liveSessions = [self liveSessionsForTabModel:self.mainTabModel];
+  [liveSessions unionSet:[self liveSessionsForTabModel:self.otrTabModel]];
+  // Keep snapshots that are less than one minute old, to prevent a concurrency
+  // issue if they are created while the purge is running.
+  [[SnapshotCache sharedInstance]
+      purgeCacheOlderThan:(base::Time::Now() - base::TimeDelta::FromMinutes(1))
+                  keeping:liveSessions];
+}
+
+- (void)markEulaAsAccepted {
+  PrefService* prefs = GetApplicationContext()->GetLocalState();
+  if (!prefs->GetBoolean(prefs::kEulaAccepted))
+    prefs->SetBoolean(prefs::kEulaAccepted, true);
+  prefs->CommitPendingWrite();
+}
+
+#pragma mark - TabOpening implementation.
+
+- (void)dismissModalsAndOpenSelectedTabInMode:(ApplicationMode)targetMode
+                                      withURL:(const GURL&)url
+                                   transition:(ui::PageTransition)transition
+                                   completion:(ProceduralBlock)handler {
+  GURL copyOfURL = url;
+  [self dismissModalDialogsWithCompletion:^{
+    [self openSelectedTabInMode:targetMode
+                        withURL:copyOfURL
+                     transition:transition];
+    if (handler)
+      handler();
+  }];
+}
+
+- (void)openTabFromLaunchOptions:(NSDictionary*)launchOptions
+              startupInformation:(id<StartupInformation>)startupInformation
+                        appState:(AppState*)appState {
+  if (launchOptions) {
+    BOOL applicationIsActive =
+        [[UIApplication sharedApplication] applicationState] ==
+        UIApplicationStateActive;
+
+    [URLOpener handleLaunchOptions:launchOptions
+                 applicationActive:applicationIsActive
+                         tabOpener:self
+                startupInformation:startupInformation
+                          appState:appState];
+  }
+}
+
+#pragma mark - SettingsNavigationControllerDelegate
+
+- (void)closeSettings {
+  [self closeSettingsAnimated:YES completion:NULL];
+}
+
+// Handle a close settings and open URL command.
+- (void)closeSettingsAndOpenUrl:(OpenUrlCommand*)command {
+  [self openUrlFromSettings:command];
+}
+
+- (void)closeSettingsAndOpenNewIncognitoTab {
+  [self closeSettingsAnimated:NO
+                   completion:^{
+                     [self createNewTabInBVC:self.otrBVC sender:nil];
+                   }];
+}
+
+#pragma mark - UserFeedbackDataSource
+
+- (NSString*)currentPageDisplayURL {
+  if (_tabSwitcherIsActive)
+    return nil;
+  web::WebState* webState = [[[self currentTabModel] currentTab] webState];
+  if (!webState)
+    return nil;
+  // Returns URL of browser tab that is currently showing.
+  GURL url = webState->GetVisibleURL();
+  base::string16 urlText = url_formatter::FormatUrl(url);
+  return base::SysUTF16ToNSString(urlText);
+}
+
+- (UIImage*)currentPageScreenshot {
+  UIView* lastView = self.mainViewController.view;
+  DCHECK(lastView);
+  CGFloat scale = 0.0;
+  // For screenshots of the Stack View we need to use a scale of 1.0 to avoid
+  // spending too much time since the Stack View can have lots of subviews.
+  if (_tabSwitcherIsActive)
+    scale = 1.0;
+  return CaptureView(lastView, scale);
+}
+
+- (BOOL)currentPageIsIncognito {
+  return [self currentBrowserState]->IsOffTheRecord();
+}
+
+- (NSString*)currentPageSyncedUserName {
+  ios::ChromeBrowserState* browserState = [self currentBrowserState];
+  if (browserState->IsOffTheRecord())
+    return nil;
+  SigninManager* signin_manager =
+      ios::SigninManagerFactory::GetForBrowserState(browserState);
+  std::string username = signin_manager->GetAuthenticatedAccountInfo().email;
+  return username.empty() ? nil : base::SysUTF8ToNSString(username);
+}
+
+#pragma mark - UI Automation Testing
+
+- (void)setUpCurrentBVCForTesting {
+  // Notify that the set up will close all tabs.
+  if (!IsIPadIdiom()) {
+    [[NSNotificationCenter defaultCenter]
+        postNotificationName:kSetupForTestingWillCloseAllTabsNotification
+                      object:self];
+  }
+
+  [self.otrTabModel closeAllTabs];
+  [self.mainTabModel closeAllTabs];
+}
+
+@end
+
+#pragma mark - TestingOnly
+
+@implementation MainController (TestingOnly)
+
+- (DeviceSharingManager*)deviceSharingManager {
+  return [_browserViewWrangler deviceSharingManager];
+}
+
+- (UIViewController<TabSwitcher>*)tabSwitcherController {
+  return _tabSwitcherController.get();
+}
+
+- (void)setTabSwitcherController:(UIViewController<TabSwitcher>*)controller {
+  _tabSwitcherController.reset([controller retain]);
+}
+
+- (SigninInteractionController*)signinInteractionController {
+  return _signinInteractionController.get();
+}
+
+- (UIViewController*)topPresentedViewController {
+  return top_view_controller::TopPresentedViewControllerFrom(
+      self.mainViewController);
+}
+
+- (void)setTabSwitcherActive:(BOOL)active {
+  _tabSwitcherIsActive = active;
+}
+
+- (BOOL)dismissingTabSwitcher {
+  return _dismissingStackView;
+}
+
+- (void)setStartupParametersWithURL:(const GURL&)launchURL {
+  NSString* sourceApplication = @"Fake App";
+  _startupParameters.reset([[ChromeAppStartupParameters
+      newChromeAppStartupParametersWithURL:net::NSURLWithGURL(launchURL)
+                     fromSourceApplication:sourceApplication] retain]);
+}
+
+- (void)setUpAsForegrounded {
+  _isColdStart = NO;
+  _browserInitializationStage = INITIALIZATION_STAGE_FOREGROUND;
+  // Create a BrowserViewWrangler with a null browser state. This will trigger
+  // assertions if the BrowserViewWrangler is asked to create any BVC or
+  // tabModel objects, but it will accept assignments to them.
+  _browserViewWrangler.reset([[BrowserViewWrangler alloc]
+      initWithBrowserState:nullptr
+          tabModelObserver:self]);
+  // This is a test utility method that bypasses the ususal setup steps, so
+  // verify that the main coordinator hasn't been created yet, then start it
+  // via lazy initialization.
+  DCHECK(!_mainCoordinator);
+  [self.mainCoordinator start];
+}
+
+- (void)setUpForTestingWithCompletionHandler:
+    (ProceduralBlock)completionHandler {
+  self.currentBVC = self.mainBVC;
+
+  int removeAllMask = ~0;
+  scoped_refptr<CallbackCounter> callbackCounter =
+      new CallbackCounter(base::BindBlock(^{
+        [self setUpCurrentBVCForTesting];
+        if (completionHandler) {
+          completionHandler();
+        }
+      }));
+  id decrementCallbackCounterCount = ^{
+    callbackCounter->DecrementCount();
+  };
+
+  callbackCounter->IncrementCount();
+  [self removeBrowsingDataFromBrowserState:_mainBrowserState
+                                      mask:removeAllMask
+                                timePeriod:browsing_data::ALL_TIME
+                         completionHandler:decrementCallbackCounterCount];
+}
+
+@end