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

ios/chrome/browser/ui/browser_view_controller.mm

+// Copyright 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#import "ios/chrome/browser/ui/browser_view_controller.h"
+
+#import <AssetsLibrary/AssetsLibrary.h>
+#import <MobileCoreServices/MobileCoreServices.h>
+#import <PassKit/PassKit.h>
+#import <Photos/Photos.h>
+#import <QuartzCore/QuartzCore.h>
+
+#include <stdint.h>
+#include <cmath>
+#include <memory>
+
+#include "base/base64.h"
+#include "base/command_line.h"
+#include "base/format_macros.h"
+#include "base/i18n/rtl.h"
+#include "base/ios/block_types.h"
+#include "base/ios/ios_util.h"
+#include "base/ios/weak_nsobject.h"
+#include "base/logging.h"
+#include "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_block.h"
+#import "base/mac/scoped_nsobject.h"
+#include "base/macros.h"
+#include "base/memory/ptr_util.h"
+#include "base/metrics/histogram.h"
+#include "base/metrics/user_metrics.h"
+#include "base/metrics/user_metrics_action.h"
+#include "base/strings/string_piece.h"
+#include "base/strings/string_util.h"
+#include "base/strings/sys_string_conversions.h"
+#include "components/bookmarks/browser/base_bookmark_model_observer.h"
+#include "components/bookmarks/browser/bookmark_model.h"
+#include "components/infobars/core/infobar_manager.h"
+#include "components/prefs/pref_service.h"
+#include "components/reading_list/core/reading_list_switches.h"
+#include "components/reading_list/ios/reading_list_model.h"
+#include "components/search_engines/search_engines_pref_names.h"
+#include "components/search_engines/template_url_service.h"
+#include "components/sessions/core/tab_restore_service_helper.h"
+#include "components/strings/grit/components_strings.h"
+#include "components/toolbar/toolbar_model_impl.h"
+#include "ios/chrome/app/tests_hook.h"
+#include "ios/chrome/browser/bookmarks/bookmark_model_factory.h"
+#include "ios/chrome/browser/browser_state/chrome_browser_state.h"
+#include "ios/chrome/browser/chrome_url_constants.h"
+#include "ios/chrome/browser/chrome_url_util.h"
+#include "ios/chrome/browser/experimental_flags.h"
+#import "ios/chrome/browser/favicon/favicon_loader.h"
+#include "ios/chrome/browser/favicon/ios_chrome_favicon_loader_factory.h"
+#import "ios/chrome/browser/find_in_page/find_in_page_controller.h"
+#import "ios/chrome/browser/find_in_page/find_in_page_model.h"
+#include "ios/chrome/browser/first_run/first_run.h"
+#import "ios/chrome/browser/geolocation/omnibox_geolocation_controller.h"
+#include "ios/chrome/browser/infobars/infobar_container_ios.h"
+#include "ios/chrome/browser/infobars/infobar_container_view.h"
+#import "ios/chrome/browser/metrics/new_tab_page_uma.h"
+#include "ios/chrome/browser/metrics/tab_usage_recorder.h"
+#import "ios/chrome/browser/native_app_launcher/native_app_navigation_controller.h"
+#import "ios/chrome/browser/open_url_util.h"
+#import "ios/chrome/browser/passwords/password_controller.h"
+#import "ios/chrome/browser/payments/payment_request_manager.h"
+#include "ios/chrome/browser/pref_names.h"
+#include "ios/chrome/browser/reading_list/reading_list_model_factory.h"
+#include "ios/chrome/browser/search_engines/template_url_service_factory.h"
+#include "ios/chrome/browser/sessions/ios_chrome_tab_restore_service_factory.h"
+#include "ios/chrome/browser/sessions/tab_restore_service_delegate_impl_ios.h"
+#include "ios/chrome/browser/sessions/tab_restore_service_delegate_impl_ios_factory.h"
+#import "ios/chrome/browser/snapshots/snapshot_cache.h"
+#import "ios/chrome/browser/snapshots/snapshot_overlay.h"
+#import "ios/chrome/browser/snapshots/snapshot_overlay_provider.h"
+#import "ios/chrome/browser/storekit_launcher.h"
+#import "ios/chrome/browser/tabs/tab.h"
+#import "ios/chrome/browser/tabs/tab_dialog_delegate.h"
+#import "ios/chrome/browser/tabs/tab_model.h"
+#import "ios/chrome/browser/tabs/tab_model_observer.h"
+#import "ios/chrome/browser/tabs/tab_snapshotting_delegate.h"
+#import "ios/chrome/browser/ui/activity_services/share_protocol.h"
+#import "ios/chrome/browser/ui/activity_services/share_to_data.h"
+#import "ios/chrome/browser/ui/alert_coordinator/alert_coordinator.h"
+#import "ios/chrome/browser/ui/authentication/re_signin_infobar_delegate.h"
+#import "ios/chrome/browser/ui/background_generator.h"
+#import "ios/chrome/browser/ui/bookmarks/bookmark_interaction_controller.h"
+#import "ios/chrome/browser/ui/browser_container_view.h"
+#import "ios/chrome/browser/ui/browser_list_ios.h"
+#import "ios/chrome/browser/ui/browser_view_controller_dependency_factory.h"
+#import "ios/chrome/browser/ui/chrome_web_view_factory.h"
+#import "ios/chrome/browser/ui/commands/UIKit+ChromeExecuteCommand.h"
+#import "ios/chrome/browser/ui/commands/generic_chrome_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/reading_list_add_command.h"
+#import "ios/chrome/browser/ui/commands/show_mail_composer_command.h"
+#import "ios/chrome/browser/ui/context_menu/context_menu_coordinator.h"
+#import "ios/chrome/browser/ui/contextual_search/contextual_search_controller.h"
+#import "ios/chrome/browser/ui/contextual_search/contextual_search_mask_view.h"
+#import "ios/chrome/browser/ui/contextual_search/contextual_search_metrics.h"
+#import "ios/chrome/browser/ui/contextual_search/contextual_search_panel_protocols.h"
+#import "ios/chrome/browser/ui/contextual_search/contextual_search_panel_view.h"
+#import "ios/chrome/browser/ui/contextual_search/touch_to_search_permissions_mediator.h"
+#import "ios/chrome/browser/ui/dialogs/dialog_presenter.h"
+#import "ios/chrome/browser/ui/dialogs/java_script_dialog_presenter_impl.h"
+#import "ios/chrome/browser/ui/elements/activity_overlay_coordinator.h"
+#import "ios/chrome/browser/ui/external_file_controller.h"
+#import "ios/chrome/browser/ui/external_file_remover.h"
+#include "ios/chrome/browser/ui/file_locations.h"
+#import "ios/chrome/browser/ui/find_bar/find_bar_controller_ios.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/tab_history_cell.h"
+#import "ios/chrome/browser/ui/key_commands_provider.h"
+#import "ios/chrome/browser/ui/no_tabs/no_tabs_controller.h"
+#import "ios/chrome/browser/ui/ntp/new_tab_page_controller.h"
+#import "ios/chrome/browser/ui/ntp/recent_tabs/recent_tabs_panel_view_controller.h"
+#include "ios/chrome/browser/ui/omnibox/page_info_model.h"
+#import "ios/chrome/browser/ui/omnibox/page_info_view_controller.h"
+#import "ios/chrome/browser/ui/overscroll_actions/overscroll_actions_controller.h"
+#import "ios/chrome/browser/ui/page_not_available_controller.h"
+#import "ios/chrome/browser/ui/preload_controller.h"
+#import "ios/chrome/browser/ui/preload_controller_delegate.h"
+#import "ios/chrome/browser/ui/print/print_controller.h"
+#import "ios/chrome/browser/ui/qr_scanner/qr_scanner_view_controller.h"
+#import "ios/chrome/browser/ui/reading_list/offline_page_native_content.h"
+#import "ios/chrome/browser/ui/reading_list/reading_list_menu_notifier.h"
+#import "ios/chrome/browser/ui/reading_list/reading_list_view_controller_builder.h"
+#include "ios/chrome/browser/ui/rtl_geometry.h"
+#import "ios/chrome/browser/ui/side_swipe/side_swipe_controller.h"
+#import "ios/chrome/browser/ui/stack_view/card_view.h"
+#import "ios/chrome/browser/ui/stack_view/page_animation_util.h"
+#import "ios/chrome/browser/ui/static_content/static_html_native_content.h"
+#import "ios/chrome/browser/ui/sync/sync_util.h"
+#import "ios/chrome/browser/ui/tab_switcher/tab_switcher_controller.h"
+#import "ios/chrome/browser/ui/tabs/tab_strip_controller.h"
+#import "ios/chrome/browser/ui/toolbar/toolbar_controller.h"
+#include "ios/chrome/browser/ui/toolbar/toolbar_model_delegate_ios.h"
+#include "ios/chrome/browser/ui/toolbar/toolbar_model_ios.h"
+#import "ios/chrome/browser/ui/tools_menu/tools_menu_context.h"
+#import "ios/chrome/browser/ui/tools_menu/tools_menu_view_item.h"
+#import "ios/chrome/browser/ui/tools_menu/tools_popup_controller.h"
+#include "ios/chrome/browser/ui/ui_util.h"
+#import "ios/chrome/browser/ui/uikit_ui_util.h"
+#import "ios/chrome/browser/ui/voice/text_to_speech_player.h"
+#include "ios/chrome/browser/upgrade/upgrade_center.h"
+#import "ios/chrome/browser/web/error_page_content.h"
+#import "ios/chrome/browser/web/passkit_dialog_provider.h"
+#import "ios/chrome/browser/xcallback_parameters.h"
+#import "ios/chrome/common/material_timing.h"
+#include "ios/chrome/grit/ios_chromium_strings.h"
+#include "ios/chrome/grit/ios_strings.h"
+#import "ios/net/request_tracker.h"
+#include "ios/public/provider/chrome/browser/chrome_browser_provider.h"
+#include "ios/public/provider/chrome/browser/ui/app_rating_prompt.h"
+#include "ios/public/provider/chrome/browser/ui/default_ios_web_view_factory.h"
+#import "ios/public/provider/chrome/browser/voice/voice_search_bar.h"
+#import "ios/public/provider/chrome/browser/voice/voice_search_bar_owner.h"
+#include "ios/public/provider/chrome/browser/voice/voice_search_controller.h"
+#include "ios/public/provider/chrome/browser/voice/voice_search_controller_delegate.h"
+#include "ios/public/provider/chrome/browser/voice/voice_search_provider.h"
+#import "ios/third_party/material_components_ios/src/components/Snackbar/src/MaterialSnackbar.h"
+#import "ios/web/navigation/crw_session_controller.h"
+#import "ios/web/navigation/crw_session_entry.h"
+#include "ios/web/navigation/navigation_manager_impl.h"
+#include "ios/web/public/active_state_manager.h"
+#include "ios/web/public/image_fetcher/image_data_fetcher.h"
+#include "ios/web/public/navigation_item.h"
+#import "ios/web/public/navigation_manager.h"
+#include "ios/web/public/referrer_util.h"
+#include "ios/web/public/ssl_status.h"
+#include "ios/web/public/url_scheme_util.h"
+#include "ios/web/public/web_client.h"
+#import "ios/web/public/web_state/context_menu_params.h"
+#import "ios/web/public/web_state/crw_web_view_proxy.h"
+#import "ios/web/public/web_state/ui/crw_native_content_provider.h"
+#include "ios/web/public/web_state/web_state.h"
+#import "ios/web/public/web_state/web_state_delegate_bridge.h"
+#include "ios/web/public/web_thread.h"
+#import "ios/web/web_state/ui/crw_web_controller.h"
+#import "net/base/mac/url_conversions.h"
+#include "net/base/registry_controlled_domains/registry_controlled_domain.h"
+#include "net/ssl/ssl_info.h"
+#include "net/url_request/url_request_context_getter.h"
+#include "third_party/google_toolbox_for_mac/src/iPhone/GTMUIImage+Resize.h"
+#include "ui/base/l10n/l10n_util.h"
+#include "ui/base/l10n/l10n_util_mac.h"
+#include "ui/base/page_transition_types.h"
+#include "url/gurl.h"
+
+using base::UserMetricsAction;
+using bookmarks::BookmarkNode;
+
+class BrowserBookmarkModelBridge;
+class InfoBarContainerDelegateIOS;
+
+namespace ios_internal {
+NSString* const kPageInfoWillShowNotification =
+    @"kPageInfoWillShowNotification";
+NSString* const kPageInfoWillHideNotification =
+    @"kPageInfoWillHideNotification";
+NSString* const kLocationBarBecomesFirstResponderNotification =
+    @"kLocationBarBecomesFirstResponderNotification";
+NSString* const kLocationBarResignsFirstResponderNotification =
+    @"kLocationBarResignsFirstResponderNotification";
+}  // namespace ios_internal
+
+namespace {
+
+typedef NS_ENUM(NSInteger, ContextMenuHistogram) {
+  // Note: these values must match the ContextMenuOption enum in histograms.xml.
+  ACTION_OPEN_IN_NEW_TAB = 0,
+  ACTION_OPEN_IN_INCOGNITO_TAB = 1,
+  ACTION_COPY_LINK_ADDRESS = 2,
+  ACTION_SAVE_IMAGE = 6,
+  ACTION_OPEN_IMAGE = 7,
+  ACTION_OPEN_IMAGE_IN_NEW_TAB = 8,
+  ACTION_SEARCH_BY_IMAGE = 11,
+  ACTION_OPEN_JAVASCRIPT = 21,
+  ACTION_READ_LATER = 22,
+  NUM_ACTIONS = 23,
+};
+
+void Record(NSInteger action, bool is_image, bool is_link) {
+  if (is_image) {
+    if (is_link) {
+      UMA_HISTOGRAM_ENUMERATION("ContextMenu.SelectedOption.ImageLink", action,
+                                NUM_ACTIONS);
+    } else {
+      UMA_HISTOGRAM_ENUMERATION("ContextMenu.SelectedOption.Image", action,
+                                NUM_ACTIONS);
+    }
+  } else {
+    UMA_HISTOGRAM_ENUMERATION("ContextMenu.SelectedOption.Link", action,
+                              NUM_ACTIONS);
+  }
+}
+
+// Duration to show or hide the No-Tabs UI.
+const NSTimeInterval kNoTabsAnimationDuration = 0.25;
+
+const CGFloat kVoiceSearchBarHeight = 59.0;
+
+// Dimensions to use when downsizing an image for search-by-image.
+const CGFloat kSearchByImageMaxImageArea = 90000.0;
+const CGFloat kSearchByImageMaxImageWidth = 600.0;
+const CGFloat kSearchByImageMaxImageHeight = 400.0;
+
+// The delay, in seconds, after startup before cleaning up the files received
+// from other applications that are not bookmarked nor referenced by an open or
+// recently closed tab.
+const int kExternalFilesCleanupDelaySeconds = 60;
+
+enum HeaderBehaviour {
+  // The header moves completely out of the screen.
+  Hideable = 0,
+  // This header stays on screen and doesn't overlap with the content.
+  Visible,
+  // This header stay on screen and covers part of the content.
+  Overlap
+};
+
+struct HeaderDefinition {
+  // The header view.
+  base::scoped_nsobject<UIView> view;
+  // How to place the view, and its behaviour when the headers move.
+  HeaderBehaviour behaviour;
+  // Reduces the height of a header to adjust for shadows.
+  CGFloat heightAdjustement;
+  // Nudges that particular header up by this number of points.
+  CGFloat inset;
+};
+
+const CGFloat kIPadFindBarOverlap = 11;
+
+bool IsURLAllowedInIncognito(const GURL& url) {
+  // Most URLs are allowed in incognito; the following are exceptions.
+  if (!url.SchemeIs(kChromeUIScheme))
+    return true;
+  std::string url_host = url.host();
+  return url_host != kChromeUIHistoryHost &&
+         url_host != kChromeUIHistoryFrameHost;
+}
+
+// Temporary key to use when storing native controllers vended to tabs before
+// they are added to the tab model.
+NSString* const kNativeControllerTemporaryKey = @"NativeControllerTemporaryKey";
+
+NSString* const kReadingListSnackbarCategory = @"ReadingListSnackbarCategory";
+
+}  // anonymous namespace
+
+@interface BrowserViewController ()<AppRatingPromptDelegate,
+                                    ContextualSearchControllerDelegate,
+                                    ContextualSearchPanelMotionObserver,
+                                    CRWNativeContentProvider,
+                                    CRWWebStateDelegate,
+                                    DialogPresenterDelegate,
+                                    FullScreenControllerDelegate,
+                                    KeyCommandsPlumbing,
+                                    MFMailComposeViewControllerDelegate,
+                                    NewTabPageControllerObserver,
+                                    OverscrollActionsControllerDelegate,
+                                    PassKitDialogProvider,
+                                    PreloadControllerDelegate,
+                                    ShareToDelegate,
+                                    SKStoreProductViewControllerDelegate,
+                                    SnapshotOverlayProvider,
+                                    StoreKitLauncher,
+                                    TabDialogDelegate,
+                                    TabModelObserver,
+                                    TabSnapshottingDelegate,
+                                    UIGestureRecognizerDelegate,
+                                    UpgradeCenterClientProtocol,
+                                    VoiceSearchBarDelegate,
+                                    VoiceSearchBarOwner> {
+  // The dependency factory passed on initialization.  Used to vend objects used
+  // by the BVC.
+  base::scoped_nsobject<BrowserViewControllerDependencyFactory>
+      _dependencyFactory;
+
+  // The browser's tab model.
+  base::scoped_nsobject<TabModel> _model;
+
+  // Facade objects used by |_toolbarController|.
+  // Must outlive |_toolbarController|.
+  std::unique_ptr<ToolbarModelDelegateIOS> _toolbarModelDelegate;
+  std::unique_ptr<ToolbarModelIOS> _toolbarModelIOS;
+
+  // Preload controller.  Must outlive |_toolbarController|.
+  base::scoped_nsobject<PreloadController> _preloadController;
+
+  // The WebToolbarController used to display the omnibox.
+  base::scoped_nsobject<WebToolbarController> _toolbarController;
+
+  // Controller for edge swipe gestures for page and tab navigation.
+  base::scoped_nsobject<SideSwipeController> _sideSwipeController;
+
+  // Handles displaying the context menu for all form factors.
+  base::scoped_nsobject<ContextMenuCoordinator> _contextMenuCoordinator;
+
+  // Backing object for property of the same name.
+  base::scoped_nsobject<DialogPresenter> _dialogPresenter;
+
+  // Handles presentation of JavaScript dialogs.
+  std::unique_ptr<JavaScriptDialogPresenterImpl> _javaScriptDialogPresenter;
+
+  // Keyboard commands provider.  It offloads most of the keyboard commands
+  // management off of the BVC.
+  base::scoped_nsobject<KeyCommandsProvider> _keyCommandsProvider;
+
+  // Calls to |-relinquishedToolbarController| will set this to yes, and calls
+  // to |-reparentToolbarController| will reset it to NO.
+  BOOL _isToolbarControllerRelinquished;
+
+  // The controller that owns the currently relinquished toolbar controller.
+  // The reference is weak because it's possible for the toolbar owner to be
+  // deallocated mid-animation due to memory pressure or a tab being closed
+  // before the animation is finished.
+  base::WeakNSObject<id> _relinquishedToolbarOwner;
+
+  // Always present on tablet; always nil on phone.
+  base::scoped_nsobject<TabStripController> _tabStripController;
+
+  // The contextual search controller.
+  base::scoped_nsobject<ContextualSearchController> _contextualSearchController;
+
+  // The contextual search panel (always a subview of |self.view| if it exists).
+  ContextualSearchPanelView* _contextualSearchPanel;
+
+  // The contextual search mask (always a subview of |self.view| if it exists).
+  ContextualSearchMaskView* _contextualSearchMask;
+
+  // Used to inject Javascript implementing the PaymentRequest API and to
+  // display the UI.
+  base::scoped_nsobject<PaymentRequestManager> _paymentRequestManager;
+
+  // Used to display the Page Info UI.  Nil if not visible.
+  base::scoped_nsobject<PageInfoViewController> _pageInfoController;
+
+  // Used to display the Voice Search UI.  Nil if not visible.
+  scoped_refptr<VoiceSearchController> _voiceSearchController;
+
+  // Used to display the QR Scanner UI. Nil if not visible.
+  base::scoped_nsobject<QRScannerViewController> _qrScannerViewController;
+
+  // Used to display the Find In Page UI. Nil if not visible.
+  base::scoped_nsobject<FindBarControllerIOS> _findBarController;
+
+  // Used to display the No-Tabs UI for iPads.  Nil if not visible.
+  base::scoped_nsobject<NoTabsController> _noTabsController;
+
+  // Used to display the Print UI. Nil if not visible.
+  base::scoped_nsobject<PrintController> _printController;
+
+  // Records the set of domains for which full screen alert has already been
+  // shown.
+  base::scoped_nsobject<NSMutableSet> _fullScreenAlertShown;
+
+  // Adapter to let BVC be the delegate for WebState.
+  std::unique_ptr<web::WebStateDelegateBridge> _webStateDelegate;
+
+  // YES if new tab is animating in.
+  BOOL _inNewTabAnimation;
+
+  // YES if Voice Search should be started when the new tab animation is
+  // finished.
+  BOOL _startVoiceSearchAfterNewTabAnimation;
+
+  // YES if the user interacts with the location bar.
+  BOOL _locationBarHasFocus;
+  // YES if a load was cancelled due to typing in the location bar.
+  BOOL _locationBarEditCancelledLoad;
+  // YES if waiting for a foreground tab due to expectNewForegroundTab.
+  BOOL _expectingForegroundTab;
+
+  // The ChromeBrowserState associated with this BVC.
+  ios::ChromeBrowserState* _browserState;  // weak
+
+  // Whether or not Incognito* is enabled.
+  BOOL _isOffTheRecord;
+
+  // The last point within |_contentArea| that's received a touch.
+  CGPoint _lastTapPoint;
+
+  // The time at which |_lastTapPoint| was most recently set.
+  CFTimeInterval _lastTapTime;
+
+  // A single infobar container handles all infobars in all tabs. It keeps
+  // track of infobars for current tab (accessed via infobar helper of
+  // the current tab).
+  std::unique_ptr<InfoBarContainerIOS> _infoBarContainer;
+
+  // Bridge class to deliver container change notifications to BVC.
+  std::unique_ptr<InfoBarContainerDelegateIOS> _infoBarContainerDelegate;
+
+  // Voice search bar at the bottom of the view overlayed on |_contentArea|
+  // when displaying voice search results. Implementation is not complete.
+  // See b/7998125.
+  base::scoped_nsprotocol<UIView<VoiceSearchBar>*> _voiceSearchBar;
+
+  // The image fetcher used to save images and perform image-based searches.
+  std::unique_ptr<web::ImageDataFetcher> _imageFetcher;
+
+  // Card side swipe view.
+  base::scoped_nsobject<CardSideSwipeView> _sideSwipeView;
+
+  // Used to cache value of |hasModeToggleSwitch| if set before the tab strip
+  // controller has been created.
+  BOOL _modeToggleNeedsSetting;
+
+  // Dominant color cache. Key: (NSString*)url, val: (UIColor*)dominantColor.
+  base::scoped_nsobject<NSMutableDictionary> _dominantColorCache;
+
+  // Bridge to register for bookmark changes.
+  std::unique_ptr<BrowserBookmarkModelBridge> _bookmarkModelBridge;
+
+  // Cached pointer to the bookmarks model.
+  bookmarks::BookmarkModel* _bookmarkModel;  // weak
+
+  // The controller that shows the bookmarking UI after the user taps the star
+  // button.
+  base::scoped_nsobject<BookmarkInteractionController>
+      _bookmarkInteractionController;
+
+  // Used to remove unreferenced external files.
+  std::unique_ptr<ExternalFileRemover> _externalFileRemover;
+
+  // The currently displayed "Rate This App" dialog, if one exists.
+  base::scoped_nsprotocol<id<AppRatingPrompt>> _rateThisAppDialog;
+
+  // Maps tab IDs to the most recent native content controller vended to that
+  // tab's web controller.
+  base::scoped_nsobject<NSMapTable> _nativeControllersForTabIDs;
+
+  // Notifies the toolbar menu of reading list changes.
+  base::scoped_nsobject<ReadingListMenuNotifier> _readingListMenuNotifier;
+
+  // The sender for the last received IDC_VOICE_SEARCH command.
+  base::WeakNSObject<UIView> _voiceSearchButton;
+
+  // Coordinator for displaying alerts.
+  base::scoped_nsobject<AlertCoordinator> _alertCoordinator;
+
+  // Releaser for properties that aren't backed by scoped_nsobjects.
+  base::mac::ObjCPropertyReleaser _propertyReleaser_BrowserViewController;
+}
+
+// The browser's side swipe controller.  Lazily instantiated on the first call.
+@property(nonatomic, retain, readonly) SideSwipeController* sideSwipeController;
+// The browser's preload controller.
+@property(nonatomic, retain, readonly) PreloadController* preloadController;
+// The dialog presenter for this BVC's tab model.
+@property(nonatomic, retain, readonly) DialogPresenter* dialogPresenter;
+// The object that manages keyboard commands on behalf of the BVC.
+@property(nonatomic, retain, readonly) KeyCommandsProvider* keyCommandsProvider;
+// Whether the current tab can enable the reader mode menu item.
+@property(nonatomic, assign, readonly) BOOL canUseReaderMode;
+// Whether the current tab can enable the request desktop menu item.
+@property(nonatomic, assign, readonly) BOOL canUseDesktopUserAgent;
+// Whether the sharing menu should be enabled.
+@property(nonatomic, assign, readonly) BOOL canShowShareMenu;
+// Helper method to check web controller canShowFindBar method.
+@property(nonatomic, assign, readonly) BOOL canShowFindBar;
+// Whether the controller's view is currently available.
+// YES from viewWillAppear to viewWillDisappear.
+@property(nonatomic, assign, getter=isVisible) BOOL visible;
+// Whether the controller's view is currently visible.
+// YES from viewDidAppear to viewWillDisappear.
+@property(nonatomic, assign) BOOL viewVisible;
+// Whether the controller is currently dismissing a presented view controller.
+@property(nonatomic, assign, getter=isDismissingModal) BOOL dismissingModal;
+// Returns YES if the toolbar has not been scrolled out by fullscreen.
+@property(nonatomic, assign, readonly, getter=isToolbarOnScreen)
+    BOOL toolbarOnScreen;
+// Whether a new tab animation is occurring.
+@property(nonatomic, assign, readonly, getter=isInNewTabAnimation)
+    BOOL inNewTabAnimation;
+// Whether BVC prefers to hide the status bar. This value is used to determine
+// the response from the |prefersStatusBarHidden| method.
+@property(nonatomic, assign) BOOL hideStatusBar;
+// Whether the VoiceSearchBar should be displayed.
+@property(nonatomic, readonly) BOOL shouldShowVoiceSearchBar;
+// Coordinator for displaying a modal overlay with activity indicator to prevent
+// the user from interacting with the browser view.
+@property(nonatomic, retain)
+    ActivityOverlayCoordinator* activityOverlayCoordinator;
+
+// BVC initialization:
+// If the BVC is initialized with a valid browser state & tab model immediately,
+// the path is straightforward: functionality is enabled, and the UI is built
+// when -viewDidLoad is called.
+// If the BVC is initialized without a browser state or tab model, the tab model
+// and browser state may or may not be provided before -viewDidLoad is called.
+// In most cases, they will not, to improve startup performance.
+// In order to handle this, initialization of various aspects of BVC have been
+// broken out into the following functions, which have expectations (enforced
+// with DCHECKs) regarding |_browserState|, |_model|, and [self isViewLoaded].
+
+// Registers for notifications.
+- (void)registerForNotifications;
+// Called when a tab is starting to load. If it's a link click or form
+// submission, the user is navigating away from any entries in the forward
+// history. Tell the toolbar so it can update the UI appropriately.
+// See the warning on [Tab webWillStartLoadingURL] about invocation of this
+// method sequence by malicious pages.
+- (void)pageLoadStarting:(NSNotification*)notify;
+// Called when a tab actually starts loading.
+- (void)pageLoadStarted:(NSNotification*)notify;
+// Called when a tab finishes loading. Update the Omnibox with the url and
+// stop any page load progess display.
+- (void)pageLoadComplete:(NSNotification*)notify;
+// Called when a tab is deselected in the model.
+// This notification also occurs when a tab is closed.
+- (void)tabDeselected:(NSNotification*)notify;
+// Animates sliding current tab and rotate-entering new tab while new tab loads
+// in background on the iPhone only.
+- (void)tabWasAdded:(NSNotification*)notify;
+
+// Updates non-view-related functionality with the given browser state and tab
+// model.
+// Does not matter whether or not the view has been loaded.
+- (void)updateWithTabModel:(TabModel*)model
+              browserState:(ios::ChromeBrowserState*)browserState;
+// On iOS7, iPad should match iOS6 status bar.  Install a simple black bar under
+// the status bar to mimic this layout.
+- (void)installFakeStatusBar;
+// Builds the UI parts of tab strip and the toolbar.  Does not matter whether
+// or not browser state and tab model are valid.
+- (void)buildToolbarAndTabStrip;
+// Updates view-related functionality with the given tab model and browser
+// state. The view must have been loaded.  Uses |_browserState| and |_model|.
+- (void)addUIFunctionalityForModelAndBrowserState;
+// Sets the correct frame and heirarchy for subviews and helper views.
+- (void)setUpViewLayout;
+// Sets the correct frame for the tab strip based on the given maximum width.
+- (void)layoutTabStripForWidth:(CGFloat)maxWidth;
+// Makes |tab| the currently visible tab, displaying its view.  Calls
+// -selectedTabChanged on the toolbar only if |newSelection| is YES.
+- (void)displayTab:(Tab*)tab isNewSelection:(BOOL)newSelection;
+// Initializes the bookmark interaction controller if not already initialized.
+- (void)initializeBookmarkInteractionController;
+
+// Shows the No-Tabs UI with animation.
+- (void)showNoTabsUI;
+// Dismisses the No-Tabs UI with animation.
+- (void)dismissNoTabsUI;
+
+// Shows the tools menu popup.
+- (void)showToolsMenuPopup;
+// Add all delegates to the provided |tab|.
+- (void)installDelegatesForTab:(Tab*)tab;
+// Closes the current tab, with animation if applicable.
+- (void)closeCurrentTab;
+// Returns an autoreleased share to data for |tab|.
+- (ShareToData*)shareToDataForTab:(Tab*)tab;
+// Shows the menu to initiate sharing |data|.
+- (void)sharePageWithData:(ShareToData*)data;
+// Convenience method to share the current page.
+- (void)sharePage;
+// Prints the web page in the current tab.
+- (void)print;
+// Shows the Online Help Page in a tab.
+- (void)showHelpPage;
+// Show the bookmarks page.
+- (void)showAllBookmarks;
+// Shows a panel within the New Tab Page.
+- (void)showNTPPanel:(NewTabPage::PanelIdentifier)panel;
+// Shows the "rate this app" dialog.
+- (void)showRateThisAppDialog;
+// Dismisses the "rate this app" dialog.
+- (void)dismissRateThisAppDialog;
+#if !defined(NDEBUG)
+// Shows the source of the current page.
+- (void)viewSource;
+#endif
+// Whether the given tab's url begins with the chrome prefix.
+- (BOOL)isTabNativePage:(Tab*)tab;
+// Returns the view to use when animating a page in or out, positioning it to
+// fill the content area but not actually adding it to the view hierarchy.
+- (UIImageView*)pageOpenCloseAnimationView;
+// Returns the view to use when animating full screen NTP paper in, filling the
+// entire screen but not actually adding it to the view hierarchy.
+- (UIImageView*)pageFullScreenOpenCloseAnimationView;
+// Updates the toolbar display based on the current tab.
+- (void)updateToolbar;
+// Updates |dialogPresenter|'s |active| property to account for the BVC's
+// |active| and |visible| properties.
+- (void)updateDialogPresenterActiveState;
+// Dismisses popups and modal dialogs that are displayed above the BVC upon size
+// changes (e.g. rotation, resizing,…) or when the accessibility escape gesture
+// is performed.
+// TODO(crbug.com/522721): Support size changes for all popups and modal
+// dialogs.
+- (void)dismissPopups;
+// Create and show the find bar.
+- (void)initFindBarForTab;
+// Search for find bar query string.
+- (void)searchFindInPage;
+// Update find bar with model data. If |shouldFocus| is set to YES, the text
+// field will become first responder.
+- (void)updateFindBar:(BOOL)initialUpdate shouldFocus:(BOOL)shouldFocus;
+// Close and disable find in page bar.
+- (void)closeFindInPage;
+// Hide find bar.
+- (void)hideFindBarWithAnimation:(BOOL)animate;
+// Shows find bar. If |selectText| is YES, all text inside the Find Bar
+// textfield will be selected. If |shouldFocus| is set to YES, the textfield is
+// set to be first responder.
+- (void)showFindBarWithAnimation:(BOOL)animate
+                      selectText:(BOOL)selectText
+                     shouldFocus:(BOOL)shouldFocus;
+// Show the Page Security Info.
+- (void)showPageInfoPopupForView:(UIView*)sourceView;
+// Hide the Page Security Info.
+- (void)hidePageInfoPopupForView:(UIView*)sourceView;
+// Shows the tab history popup containing the tab's backward history.
+- (void)showTabHistoryPopupForBackwardHistory;
+// Shows the tab history popup containing the tab's forward history.
+- (void)showTabHistoryPopupForForwardHistory;
+// Navigate back/forward to the selected entry in the tab's history.
+- (void)navigateToSelectedEntry:(id)sender;
+// The infobar state (typically height) has changed.
+- (void)infoBarContainerStateChanged:(bool)is_animating;
+// Adds a CardView on top of the contentArea either taking the size of the full
+// screen or just the size of the space under the header.
+// Returns the CardView that was added.
+- (CardView*)addCardViewInFullscreen:(BOOL)fullScreen;
+// Called when either a tab finishes loading or when a tab with finished content
+// is added directly to the model via pre-rendering. The tab must be non-nil and
+// must be a member of the tab model controlled by this BrowserViewController.
+- (void)tabLoadComplete:(Tab*)tab withSuccess:(BOOL)success;
+// Evaluates Javascript asynchronously using the current page context.
+- (void)openJavascript:(NSString*)javascript;
+// Sets the desktop user agent flag and reload the current page.
+- (void)enableDesktopUserAgent;
+// Helper methods used by ShareToDelegate methods.
+// Shows an alert with the given title and message id.
+- (void)showErrorAlert:(int)titleMessageId message:(int)messageId;
+// Helper method displaying an alert with the given title and message.
+// Dismisses previous alert if it has not been dismissed yet.
+- (void)showErrorAlertWithStringTitle:(NSString*)title
+                              message:(NSString*)message;
+// Shows a self-dismissing snackbar displaying |message|.
+- (void)showSnackbar:(NSString*)message;
+// Induces an intentional crash in the browser process.
+- (void)induceBrowserCrash;
+// Saves the image or display error message, based on privacy settings.
+- (void)managePermissionAndSaveImage:(NSData*)data fileName:(NSString*)fileName;
+// Saves the image. In order to keep the metadata of the image, the image is
+// saved as a temporary file on disk then saved in photos.
+// This should be called on FILE thread.
+- (void)saveImage:(NSData*)data fileName:(NSString*)fileName;
+// Called when Chrome has been denied access to the photos or videos and the
+// user can change it.
+// Shows a privacy alert on the main queue, allowing the user to go to Chrome's
+// settings. Dismiss previous alert if it has not been dismissed yet.
+- (void)displayImageErrorAlertWithSettingsOnMainQueue;
+// Shows a privacy alert allowing the user to go to Chrome's settings. Dismiss
+// previous alert if it has not been dismissed yet.
+- (void)displayImageErrorAlertWithSettings:(NSURL*)settingURL;
+// Called when Chrome has been denied access to the photos or videos and the
+// user cannot change it.
+// Shows a privacy alert on the main queue, with errorContent as the message.
+// Dismisses previous alert if it has not been dismissed yet.
+- (void)displayPrivacyErrorAlertOnMainQueue:(NSString*)errorContent;
+// Called with the results of saving a picture in the photo album. If error is
+// nil the save succeeded.
+- (void)finishSavingImageWithError:(NSError*)error;
+// Provides a view that encompasses currently displayed infobar(s) or nil
+// if no infobar is presented.
+- (UIView*)infoBarOverlayViewForTab:(Tab*)tab;
+// Returns a vertical infobar offset relative to the tab content.
+- (CGFloat)infoBarOverlayYOffsetForTab:(Tab*)tab;
+// Provides a view that encompasses the voice search bar if it's displayed or
+// nil if the voice search bar isn't displayed.
+- (UIView*)voiceSearchOverlayViewForTab:(Tab*)tab;
+// Returns a vertical voice search bar offset relative to the tab content.
+- (CGFloat)voiceSearchOverlayYOffsetForTab:(Tab*)tab;
+// Lazily instantiates |_voiceSearchController|.
+- (void)ensureVoiceSearchControllerCreated;
+// Lazily instantiates |_voiceSearchBar| and adds it to the view.
+- (void)ensureVoiceSearchBarCreated;
+// Shows/hides the voice search bar.
+- (void)updateVoiceSearchBarVisibilityAnimated:(BOOL)animated;
+// The LogoAnimationControllerOwner to be used for the next logo transition
+// animation.
+- (id<LogoAnimationControllerOwner>)currentLogoAnimationControllerOwner;
+// Returns the header views, all the chrome on top of the page, including the
+// ones that cannot be scrolled off screen by full screen.
+- (const std::vector<HeaderDefinition>)headerViews;
+// Returns the footer view if one exists (e.g. the voice search bar).
+- (UIView*)footerView;
+// Returns the height of the header view for the tab model's current tab.
+- (CGFloat)headerHeight;
+// Returns the height of the header view for |tab|.
+- (CGFloat)headerHeightForTab:(Tab*)tab;
+// Sets the frame for the headers.
+- (void)setFramesForHeaders:(const std::vector<HeaderDefinition>)headers
+                   atOffset:(CGFloat)headerOffset;
+// Returns the y coordinate for the footer's frame when animating the footer
+// in/out of fullscreen.
+- (CGFloat)footerYForHeaderOffset:(CGFloat)headerOffset;
+// Called when the animation for setting the header view's offset is finished.
+// |completed| should indicate if the animation finished completely or was
+// interrupted. |offset| should indicate the header offset after the animation.
+// |dragged| should indicate if the header moved due to the user dragging.
+- (void)fullScreenController:(FullScreenController*)controller
+    headerAnimationCompleted:(BOOL)completed
+                      offset:(CGFloat)offset;
+// Performs a search with the image at the given url. The referrer is used to
+// download the image.
+- (void)searchByImageAtURL:(const GURL&)url
+                  referrer:(const web::Referrer)referrer;
+// Saves the image at the given URL on the system's album.  The referrer is used
+// to download the image.
+- (void)saveImageAtURL:(const GURL&)url referrer:(const web::Referrer&)referrer;
+
+// Determines the center of |sender| if it's a view or a toolbar item, and save
+// the CGPoint and timestamp.
+- (void)setLastTapPoint:(id)sender;
+// Get return the last stored |_lastTapPoint| if it's been set within the past
+// second.
+- (CGPoint)lastTapPoint;
+// Store the tap CGPoint in |_lastTapPoint| and the current timestamp.
+- (void)saveContentAreaTapLocation:(UIGestureRecognizer*)gestureRecognizer;
+// Returns the native controller being used by |tab|'s web controller.
+- (id)nativeControllerForTab:(Tab*)tab;
+// Installs the BVC as overscroll actions controller of |nativeContent| if
+// needed. Sets the style of the overscroll actions toolbar.
+- (void)setOverScrollActionControllerToStaticNativeContent:
+    (StaticHtmlNativeContent*)nativeContent;
+// Whether the BVC should declare keyboard commands.
+- (BOOL)shouldRegisterKeyboardCommands;
+// Adds the given url to the reading list.
+- (void)addToReadingListURL:(const GURL&)URL title:(NSString*)title;
+@end
+
+class InfoBarContainerDelegateIOS
+    : public infobars::InfoBarContainer::Delegate {
+ public:
+  explicit InfoBarContainerDelegateIOS(BrowserViewController* controller)
+      : controller_(controller) {}
+
+  ~InfoBarContainerDelegateIOS() override {}
+
+ private:
+  SkColor GetInfoBarSeparatorColor() const override {
+    NOTIMPLEMENTED();
+    return SK_ColorBLACK;
+  }
+
+  int ArrowTargetHeightForInfoBar(
+      size_t index,
+      const gfx::SlideAnimation& animation) const override {
+    return 0;
+  }
+
+  void ComputeInfoBarElementSizes(const gfx::SlideAnimation& animation,
+                                  int arrow_target_height,
+                                  int bar_target_height,
+                                  int* arrow_height,
+                                  int* arrow_half_width,
+                                  int* bar_height) const override {
+    DCHECK_NE(-1, bar_target_height)
+        << "Infobars don't have a default height on iOS";
+    *arrow_height = 0;
+    *arrow_half_width = 0;
+    *bar_height = animation.CurrentValueBetween(0, bar_target_height);
+  }
+
+  void InfoBarContainerStateChanged(bool is_animating) override {
+    [controller_ infoBarContainerStateChanged:is_animating];
+  }
+
+  bool DrawInfoBarArrows(int* x) const override { return false; }
+
+  BrowserViewController* controller_;  // weak
+};
+
+// Called from the BrowserBookmarkModelBridge from C++ -> ObjC.
+@interface BrowserViewController (BookmarkBridgeMethods)
+// If a bookmark matching the currentTab url is added or moved, update the
+// toolbar state so the star highlight is in sync.
+- (void)bookmarkNodeModified:(const BookmarkNode*)node;
+- (void)allBookmarksRemoved;
+@end
+
+// Handle notification that bookmarks has been removed changed so we can update
+// the bookmarked star icon.
+class BrowserBookmarkModelBridge : public bookmarks::BookmarkModelObserver {
+ public:
+  explicit BrowserBookmarkModelBridge(BrowserViewController* owner)
+      : owner_(owner) {}
+
+  ~BrowserBookmarkModelBridge() override {}
+
+  void BookmarkNodeRemoved(bookmarks::BookmarkModel* model,
+                           const BookmarkNode* parent,
+                           int old_index,
+                           const BookmarkNode* node,
+                           const std::set<GURL>& removed_urls) override {
+    [owner_ bookmarkNodeModified:node];
+  }
+
+  void BookmarkModelLoaded(bookmarks::BookmarkModel* model,
+                           bool ids_reassigned) override {}
+
+  void BookmarkNodeMoved(bookmarks::BookmarkModel* model,
+                         const BookmarkNode* old_parent,
+                         int old_index,
+                         const BookmarkNode* new_parent,
+                         int new_index) override {}
+
+  void BookmarkNodeAdded(bookmarks::BookmarkModel* model,
+                         const BookmarkNode* parent,
+                         int index) override {
+    [owner_ bookmarkNodeModified:parent->GetChild(index)];
+  }
+
+  void BookmarkNodeChanged(bookmarks::BookmarkModel* model,
+                           const BookmarkNode* node) override {}
+
+  void BookmarkNodeFaviconChanged(bookmarks::BookmarkModel* model,
+                                  const BookmarkNode* node) override {}
+
+  void BookmarkNodeChildrenReordered(bookmarks::BookmarkModel* model,
+                                     const BookmarkNode* node) override {}
+
+  void BookmarkAllUserNodesRemoved(
+      bookmarks::BookmarkModel* model,
+      const std::set<GURL>& removed_urls) override {
+    [owner_ allBookmarksRemoved];
+  }
+
+ private:
+  BrowserViewController* owner_;  // Weak.
+};
+
+@implementation BrowserViewController
+
+@synthesize contentArea = _contentArea;
+@synthesize typingShield = _typingShield;
+@synthesize active = _active;
+@synthesize visible = _visible;
+@synthesize viewVisible = _viewVisible;
+@synthesize dismissingModal = _dismissingModal;
+@synthesize hideStatusBar = _hideStatusBar;
+@synthesize activityOverlayCoordinator = _activityOverlayCoordinator;
+@synthesize presenting = _presenting;
+
+#pragma mark - Object lifecycle
+
+- (instancetype)initWithTabModel:(TabModel*)model
+                    browserState:(ios::ChromeBrowserState*)browserState
+               dependencyFactory:
+                   (BrowserViewControllerDependencyFactory*)factory {
+  self = [super initWithNibName:nil bundle:base::mac::FrameworkBundle()];
+  if (self) {
+    DCHECK(factory);
+    _propertyReleaser_BrowserViewController.Init(self,
+                                                 [BrowserViewController class]);
+    _imageFetcher = base::MakeUnique<web::ImageDataFetcher>(
+        web::WebThread::GetBlockingPool());
+    _dependencyFactory.reset([factory retain]);
+    _nativeControllersForTabIDs.reset(
+        [[NSMapTable strongToWeakObjectsMapTable] retain]);
+    _dialogPresenter.reset([[DialogPresenter alloc] initWithDelegate:self
+                                            presentingViewController:self]);
+    _javaScriptDialogPresenter.reset(
+        new JavaScriptDialogPresenterImpl(_dialogPresenter));
+    _webStateDelegate.reset(new web::WebStateDelegateBridge(self));
+    // TODO(leng): Delay this.
+    [[UpgradeCenter sharedInstance] registerClient:self];
+    _inNewTabAnimation = NO;
+    BrowserListIOS::AddBrowser(self);
+    if (model && browserState)
+      [self updateWithTabModel:model browserState:browserState];
+    if ([[NSUserDefaults standardUserDefaults]
+            boolForKey:@"fullScreenShowAlert"]) {
+      _fullScreenAlertShown.reset([[NSMutableSet alloc] init]);
+    }
+  }
+  return self;
+}
+
+- (instancetype)initWithNibName:(NSString*)nibNameOrNil
+                         bundle:(NSBundle*)nibBundleOrNil {
+  NOTREACHED();
+  return nil;
+}
+
+- (instancetype)initWithCoder:(NSCoder*)aDecoder {
+  NOTREACHED();
+  return nil;
+}
+
+- (void)dealloc {
+  _tabStripController.reset();
+  _infoBarContainer.reset();
+  _readingListMenuNotifier.reset();
+  BrowserListIOS::RemoveBrowser(self);
+  _bookmarkModel->RemoveObserver(_bookmarkModelBridge.get());
+  [_model removeObserver:self];
+  [[UpgradeCenter sharedInstance] unregisterClient:self];
+  [[NSNotificationCenter defaultCenter] removeObserver:self];
+  [_toolbarController setDelegate:nil];
+  if (_voiceSearchController.get())
+    _voiceSearchController->SetDelegate(nil);
+  [_rateThisAppDialog setDelegate:nil];
+  [_model closeAllTabs];
+  [super dealloc];
+}
+
+#pragma mark - Accessibility
+
+- (BOOL)accessibilityPerformEscape {
+  [self dismissPopups];
+  return YES;
+}
+
+#pragma mark - Properties
+
+// Implements |hasModeToggleSwitch| property as pass-throughs to tab strip
+// controller and no-tabs controller. If set before the controller has been
+// created, cache it.
+- (void)setHasModeToggleSwitch:(BOOL)hasModeToggleSwitch {
+  if (!experimental_flags::IsTabSwitcherEnabled()) {
+    if (_tabStripController)
+      _tabStripController.get().hasModeToggleSwitch = hasModeToggleSwitch;
+    else
+      _modeToggleNeedsSetting = hasModeToggleSwitch;
+  }
+  [_noTabsController setHasModeToggleSwitch:hasModeToggleSwitch];
+}
+
+// Implements |hasModeToggleSwitch| property as pass-throughs to tab strip
+// controller, unless it hasn't been created in which return the cached version.
+- (BOOL)hasModeToggleSwitch {
+  if (_tabStripController)
+    return _tabStripController.get().hasModeToggleSwitch;
+  return _modeToggleNeedsSetting;
+}
+
+- (void)setActive:(BOOL)active {
+  if (_active == active) {
+    return;
+  }
+  _active = active;
+
+  // If not active, display an activity indicator overlay over the view to
+  // prevent interaction with the web page.
+  // TODO(crbug.com/637093): This coordinator should be managed by the
+  // coordinator used to present BrowserViewController, when implemented.
+  if (active) {
+    [self.activityOverlayCoordinator stop];
+    self.activityOverlayCoordinator = nil;
+  } else if (!self.activityOverlayCoordinator) {
+    self.activityOverlayCoordinator = [[[ActivityOverlayCoordinator alloc]
+        initWithBaseViewController:self] autorelease];
+    [self.activityOverlayCoordinator start];
+  }
+
+  if (_browserState) {
+    web::ActiveStateManager* active_state_manager =
+        web::BrowserState::GetActiveStateManager(_browserState);
+    active_state_manager->SetActive(active);
+  }
+
+  [_model setWebUsageEnabled:active];
+  [self updateDialogPresenterActiveState];
+
+  if (active) {
+    // Make sure the tab (if any; it's possible to get here without a current
+    // tab if the caller is about to create one) ends up on screen completely.
+    Tab* currentTab = [_model currentTab];
+    // Force loading the view in case it was not loaded yet.
+    [self ensureViewCreated];
+    if (_expectingForegroundTab)
+      [currentTab.webController setOverlayPreviewMode:YES];
+    if (currentTab)
+      [self displayTab:currentTab isNewSelection:YES];
+  }
+  [_contextualSearchController enableContextualSearch:active];
+  [_paymentRequestManager enablePaymentRequest:active];
+
+  [self setNeedsStatusBarAppearanceUpdate];
+}
+
+- (void)setPrimary:(BOOL)primary {
+  [_model setPrimary:primary];
+  if (primary) {
+    [self updateDialogPresenterActiveState];
+  } else {
+    self.dialogPresenter.active = false;
+  }
+}
+
+- (BOOL)isPlayingTTS {
+  return _voiceSearchController && _voiceSearchController->IsPlayingAudio();
+}
+
+- (SideSwipeController*)sideSwipeController {
+  if (!_sideSwipeController) {
+    _sideSwipeController.reset([[SideSwipeController alloc]
+        initWithTabModel:_model
+            browserState:_browserState]);
+    [_sideSwipeController setSnapshotDelegate:self];
+    [_sideSwipeController setSwipeDelegate:self];
+  }
+  return _sideSwipeController;
+}
+
+- (PreloadController*)preloadController {
+  return _preloadController.get();
+}
+
+- (DialogPresenter*)dialogPresenter {
+  return _dialogPresenter;
+}
+
+- (BOOL)canUseReaderMode {
+  Tab* tab = [_model currentTab];
+  if ([self isTabNativePage:tab])
+    return NO;
+
+  return [tab canSwitchToReaderMode];
+}
+
+- (BOOL)canUseDesktopUserAgent {
+  Tab* tab = [_model currentTab];
+  if ([self isTabNativePage:tab])
+    return NO;
+
+  // If |useDesktopUserAgent| is |NO|, allow useDesktopUserAgent.
+  return !tab.useDesktopUserAgent;
+}
+
+// Whether the sharing menu should be shown.
+- (BOOL)canShowShareMenu {
+  Tab* tab = [_model currentTab];
+  // TODO(shreyasv): Make it so the URL returned by the tab is always valid and
+  // remove check on net::NSURLWithGURL(tab.url) ( http://crbug.com/400999 ).
+  return tab && !tab.url.SchemeIs(kChromeUIScheme) &&
+         net::NSURLWithGURL(tab.url);
+}
+
+- (BOOL)canShowFindBar {
+  // Make sure web controller can handle find in page.
+  Tab* tab = [_model currentTab];
+  if (![tab.findInPageController canFindInPage])
+    return NO;
+
+  // Don't show twice.
+  if (tab.findInPageController.findInPageModel.enabled)
+    return NO;
+
+  return YES;
+}
+
+- (void)setVisible:(BOOL)visible {
+  if (_visible == visible)
+    return;
+  _visible = visible;
+}
+
+- (void)setViewVisible:(BOOL)viewVisible {
+  if (_viewVisible == viewVisible)
+    return;
+  _viewVisible = viewVisible;
+  self.visible = viewVisible;
+  [self updateDialogPresenterActiveState];
+}
+
+- (BOOL)isToolbarOnScreen {
+  return [self headerHeight] - [self currentHeaderOffset] > 0;
+}
+
+- (BOOL)isInNewTabAnimation {
+  return _inNewTabAnimation;
+}
+
+- (BOOL)shouldShowVoiceSearchBar {
+  // On iPads, the voice search bar should only be shown for regular horizontal
+  // size class configurations.  It should always be shown for voice search
+  // results Tabs on iPhones, including configurations with regular horizontal
+  // size classes (i.e. landscape iPhone 6 Plus).
+  BOOL compactWidth = self.traitCollection.horizontalSizeClass ==
+                      UIUserInterfaceSizeClassCompact;
+  return self.tabModel.currentTab.isVoiceSearchResultsTab &&
+         (!IsIPadIdiom() || compactWidth);
+}
+
+- (void)setHideStatusBar:(BOOL)hideStatusBar {
+  if (_hideStatusBar == hideStatusBar)
+    return;
+  _hideStatusBar = hideStatusBar;
+  [self setNeedsStatusBarAppearanceUpdate];
+}
+
+#pragma mark - IBActions
+
+- (void)shieldWasTapped:(id)sender {
+  [_toolbarController cancelOmniboxEdit];
+}
+
+- (void)newTab:(id)sender {
+  [self setLastTapPoint:sender];
+  DCHECK(self.visible || self.dismissingModal);
+  Tab* currentTab = [_model currentTab];
+  if (currentTab) {
+    BOOL isChromeScheme =
+        web::GetWebClient()->IsAppSpecificURL([currentTab url]);
+    BOOL snapshotOnIpad =
+        (!IsIPadIdiom() || experimental_flags::IsTabSwitcherEnabled());
+    if (snapshotOnIpad || !isChromeScheme) {
+      [currentTab updateSnapshotWithOverlay:YES visibleFrameOnly:YES];
+    }
+  }
+  [self addSelectedTabWithURL:GURL(kChromeUINewTabURL)
+                   transition:ui::PAGE_TRANSITION_TYPED];
+}
+
+#pragma mark - UIViewController methods
+
+// Perform additional set up after loading the view, typically from a nib.
+- (void)viewDidLoad {
+  // Duplicate .xib layout for now.
+  CGRect initialViewsRect = CGRectMake(0, 30, 320, 430);
+  UIViewAutoresizing initialViewAutoresizing =
+      UIViewAutoresizingFlexibleWidth | UIViewAutoresizingFlexibleHeight;
+
+  self.contentArea = [[[BrowserContainerView alloc]
+      initWithFrame:initialViewsRect] autorelease];
+  self.contentArea.autoresizingMask = initialViewAutoresizing;
+  self.typingShield =
+      [[[UIButton alloc] initWithFrame:initialViewsRect] autorelease];
+  self.typingShield.autoresizingMask = initialViewAutoresizing;
+  [self.typingShield addTarget:self
+                        action:@selector(shieldWasTapped:)
+              forControlEvents:UIControlEventTouchUpInside];
+  self.view.bounds = CGRectMake(0, 0, 320, 460);
+  self.view.autoresizingMask = initialViewAutoresizing;
+  self.view.backgroundColor = [UIColor colorWithWhite:0.75 alpha:1.0];
+  [self.view addSubview:self.contentArea];
+  [self.view addSubview:self.typingShield];
+  [super viewDidLoad];
+
+  // Install fake status bar for iPad iOS7
+  [self installFakeStatusBar];
+  [self buildToolbarAndTabStrip];
+  [self setUpViewLayout];
+  // If the tab model and browser state are valid, finish initialization.
+  if (_model && _browserState)
+    [self addUIFunctionalityForModelAndBrowserState];
+
+  // Add a tap gesture recognizer to save the last tap location for the source
+  // location of the new tab animation.
+  base::scoped_nsobject<UITapGestureRecognizer> tapRecognizer(
+      [[UITapGestureRecognizer alloc]
+          initWithTarget:self
+                  action:@selector(saveContentAreaTapLocation:)]);
+  [tapRecognizer setDelegate:self];
+  [tapRecognizer setCancelsTouchesInView:NO];
+  [_contentArea addGestureRecognizer:tapRecognizer];
+}
+
+- (void)viewDidAppear:(BOOL)animated {
+  [super viewDidAppear:animated];
+  self.viewVisible = YES;
+  [self updateDialogPresenterActiveState];
+}
+
+- (void)viewWillAppear:(BOOL)animated {
+  [super viewWillAppear:animated];
+
+  // Reparent the toolbar if it's been relinquished.
+  if (_isToolbarControllerRelinquished)
+    [self reparentToolbarController];
+
+  self.visible = YES;
+
+  // Restore hidden infobars.
+  if (IsIPadIdiom() && experimental_flags::IsTabSwitcherEnabled()) {
+    _infoBarContainer->RestoreInfobars();
+  }
+
+  // If the controller is suspended, or has been paged out due to low memory,
+  // updating the view will be handled when it's displayed again.
+  if (![_model webUsageEnabled] || !self.contentArea)
+    return;
+  // Update the displayed tab (if any; the switcher may not have created one
+  // yet) in case it changed while showing the switcher.
+  Tab* currentTab = [_model currentTab];
+  if (currentTab)
+    [self displayTab:currentTab isNewSelection:YES];
+}
+
+- (void)viewWillDisappear:(BOOL)animated {
+  self.viewVisible = NO;
+  [self updateDialogPresenterActiveState];
+  [[_model currentTab] updateFullscreenWithToolbarVisible:YES];
+  [[_model currentTab] wasHidden];
+  [_bookmarkInteractionController dismissSnackbar];
+  if (IsIPadIdiom() && experimental_flags::IsTabSwitcherEnabled()) {
+    _infoBarContainer->SuspendInfobars();
+  }
+  [super viewWillDisappear:animated];
+}
+
+- (void)willRotateToInterfaceOrientation:(UIInterfaceOrientation)orient
+                                duration:(NSTimeInterval)duration {
+  [super willRotateToInterfaceOrientation:orient duration:duration];
+  [self dismissPopups];
+  [self reshowFindBarIfNeededWithCoordinator:nil];
+}
+
+- (void)didRotateFromInterfaceOrientation:(UIInterfaceOrientation)orient {
+  [super didRotateFromInterfaceOrientation:orient];
+
+  // This reinitializes the toolbar, including updating the Overlay View,
+  // if there is one.
+  [self updateToolbar];
+  [self infoBarContainerStateChanged:false];
+}
+
+- (BOOL)prefersStatusBarHidden {
+  return self.hideStatusBar;
+}
+
+// Called when in the foreground and the OS needs more memory. Release as much
+// as possible.
+- (void)didReceiveMemoryWarning {
+  // Releases the view if it doesn't have a superview.
+  [super didReceiveMemoryWarning];
+
+  // Release any cached data, images, etc that aren't in use.
+  // TODO(pinkerton): This feels like it should go in the MemoryPurger class,
+  // but since the FaviconCache uses obj-c in the header, it can't be included
+  // there.
+  if (_browserState) {
+    FaviconLoader* loader =
+        IOSChromeFaviconLoaderFactory::GetForBrowserStateIfExists(
+            _browserState);
+    if (loader)
+      loader->PurgeCache();
+  }
+
+  if (![self isViewLoaded]) {
+    // Do not release |_infoBarContainer|, as this must have the same lifecycle
+    // as the BrowserViewController.
+    self.contentArea = nil;
+    self.typingShield = nil;
+    if (_voiceSearchController.get())
+      _voiceSearchController->SetDelegate(nil);
+    _qrScannerViewController.reset();
+    _toolbarController.reset();
+    _toolbarModelDelegate.reset();
+    _toolbarModelIOS.reset();
+    _tabStripController.reset();
+    _noTabsController.reset();
+    _sideSwipeController.reset();
+  }
+}
+
+- (void)traitCollectionDidChange:(UITraitCollection*)previousTraitCollection {
+  [super traitCollectionDidChange:previousTraitCollection];
+  // TODO(crbug.com/527092): - traitCollectionDidChange: is not always forwarded
+  // because in some cases the presented view controller isn't a child of the
+  // BVC in the view controller hierarchy (some intervening object isn't a
+  // view controller).
+  [self.presentedViewController
+      traitCollectionDidChange:previousTraitCollection];
+  [_toolbarController traitCollectionDidChange:previousTraitCollection];
+  // Update voice search bar visibility.
+  [self updateVoiceSearchBarVisibilityAnimated:NO];
+}
+
+- (void)viewWillTransitionToSize:(CGSize)size
+       withTransitionCoordinator:
+           (id<UIViewControllerTransitionCoordinator>)coordinator {
+  [super viewWillTransitionToSize:size withTransitionCoordinator:coordinator];
+  [self dismissPopups];
+  [self reshowFindBarIfNeededWithCoordinator:coordinator];
+}
+
+- (void)reshowFindBarIfNeededWithCoordinator:
+    (id<UIViewControllerTransitionCoordinator>)coordinator {
+  if (![_findBarController isFindInPageShown])
+    return;
+
+  // Record focused state.
+  BOOL isFocusedBeforeReshow = [_findBarController isFocused];
+
+  [self hideFindBarWithAnimation:NO];
+
+  base::WeakNSObject<BrowserViewController> weakSelf(self);
+  void (^completion)(id<UIViewControllerTransitionCoordinatorContext>) = ^(
+      id<UIViewControllerTransitionCoordinatorContext> context) {
+    base::scoped_nsobject<BrowserViewController> strongSelf([weakSelf retain]);
+    if (strongSelf)
+      [strongSelf showFindBarWithAnimation:NO
+                                selectText:NO
+                               shouldFocus:isFocusedBeforeReshow];
+  };
+
+  BOOL enqueued =
+      [coordinator animateAlongsideTransition:nil completion:completion];
+  if (!enqueued) {
+    completion(nil);
+  }
+}
+
+- (void)dismissViewControllerAnimated:(BOOL)flag
+                           completion:(void (^)())completion {
+  self.dismissingModal = YES;
+  base::WeakNSObject<BrowserViewController> weakSelf(self);
+  [super dismissViewControllerAnimated:flag
+                            completion:^{
+                              base::scoped_nsobject<BrowserViewController>
+                                  strongSelf([weakSelf retain]);
+                              [strongSelf setDismissingModal:NO];
+                              [strongSelf setPresenting:NO];
+                              if (completion)
+                                completion();
+                              [[strongSelf dialogPresenter] tryToPresent];
+                            }];
+}
+
+- (void)presentViewController:(UIViewController*)viewControllerToPresent
+                     animated:(BOOL)flag
+                   completion:(void (^)())completion {
+  base::mac::ScopedBlock<ProceduralBlock> finalCompletionHandler(
+      [completion copy]);
+  // TODO(crbug.com/580098) This is an interim fix for the flicker between the
+  // launch screen and the FRE Animation. The fix is, if the FRE is about to be
+  // presented, to show a temporary view of the launch screen and then remove it
+  // when the controller for the FRE has been presented. This fix should be
+  // removed when the FRE startup code is rewritten.
+  BOOL firstRunLaunch = (FirstRun::IsChromeFirstRun() ||
+                         experimental_flags::AlwaysDisplayFirstRun()) &&
+                        !tests_hook::DisableFirstRun();
+  // These if statements check that |presentViewController| is being called for
+  // the FRE case.
+  if (firstRunLaunch &&
+      [viewControllerToPresent isKindOfClass:[UINavigationController class]]) {
+    UINavigationController* navController =
+        base::mac::ObjCCastStrict<UINavigationController>(
+            viewControllerToPresent);
+    if ([navController.topViewController
+            isMemberOfClass:[WelcomeToChromeViewController class]]) {
+      self.hideStatusBar = YES;
+
+      // Load view from Launch Screen and add it to window.
+      NSBundle* mainBundle = base::mac::FrameworkBundle();
+      NSArray* topObjects =
+          [mainBundle loadNibNamed:@"LaunchScreen" owner:self options:nil];
+      UIViewController* launchScreenController =
+          base::mac::ObjCCastStrict<UIViewController>([topObjects lastObject]);
+      // |launchScreenView| is loaded as an autoreleased object, and is retained
+      // by the |completion| block below.
+      UIView* launchScreenView = launchScreenController.view;
+      launchScreenView.userInteractionEnabled = NO;
+      launchScreenView.frame = self.view.window.bounds;
+      [self.view.window addSubview:launchScreenView];
+
+      // Replace the completion handler sent to the superclass with one which
+      // removes |launchScreenView| and resets the status bar. If |completion|
+      // exists, it is called from within the new completion handler.
+      base::WeakNSObject<BrowserViewController> weakSelf(self);
+      finalCompletionHandler.reset([^{
+        [launchScreenView removeFromSuperview];
+        weakSelf.get().hideStatusBar = NO;
+        if (completion)
+          completion();
+      } copy]);
+    }
+  }
+
+  self.presenting = YES;
+
+  [super presentViewController:viewControllerToPresent
+                      animated:flag
+                    completion:finalCompletionHandler];
+}
+
+#pragma mark - Notification handling
+
+- (void)registerForNotifications {
+  DCHECK(_model);
+  NSNotificationCenter* defaultCenter = [NSNotificationCenter defaultCenter];
+  [defaultCenter addObserver:self
+                    selector:@selector(pageLoadStarting:)
+                        name:kTabModelTabWillStartLoadingNotification
+                      object:_model];
+  [defaultCenter addObserver:self
+                    selector:@selector(pageLoadStarted:)
+                        name:kTabModelTabDidStartLoadingNotification
+                      object:_model];
+  [defaultCenter addObserver:self
+                    selector:@selector(pageLoadComplete:)
+                        name:kTabModelTabDidFinishLoadingNotification
+                      object:_model];
+  [defaultCenter addObserver:self
+                    selector:@selector(tabDeselected:)
+                        name:kTabModelTabDeselectedNotification
+                      object:_model];
+  [defaultCenter addObserver:self
+                    selector:@selector(tabWasAdded:)
+                        name:kTabModelNewTabWillOpenNotification
+                      object:_model];
+}
+
+- (void)pageLoadStarting:(NSNotification*)notify {
+  Tab* tab = notify.userInfo[kTabModelTabKey];
+  DCHECK(tab && ([_model indexOfTab:tab] != NSNotFound));
+  // Hide find bar when navigating to a new page.
+  [self hideFindBarWithAnimation:NO];
+  tab.findInPageController.findInPageModel.enabled = NO;
+  if (tab == [_model currentTab]) {
+    // TODO(pinkerton): Fill in here about hiding the forward button on
+    // navigation.
+  }
+}
+
+- (void)pageLoadStarted:(NSNotification*)notify {
+  Tab* tab = notify.userInfo[kTabModelTabKey];
+  DCHECK(tab);
+  if (tab == [_model currentTab]) {
+    if (![self isTabNativePage:tab]) {
+      [_toolbarController currentPageLoadStarted];
+    }
+    [self updateVoiceSearchBarVisibilityAnimated:NO];
+  }
+}
+
+- (void)pageLoadComplete:(NSNotification*)notify {
+  // Update the UI, but only if the current tab.
+  Tab* tab = notify.userInfo[kTabModelTabKey];
+  if (tab == [_model currentTab]) {
+    // There isn't any need to update the toolbar here. When the page finishes,
+    // it will have already sent us |-tabModel:didChangeTab:| which will do it.
+  }
+
+  BOOL loadingSucceeded = [notify.userInfo[kTabModelPageLoadSuccess] boolValue];
+
+  [self tabLoadComplete:tab withSuccess:loadingSucceeded];
+}
+
+- (void)tabDeselected:(NSNotification*)notify {
+  DCHECK(notify);
+  Tab* tab = notify.userInfo[kTabModelTabKey];
+  DCHECK(tab);
+  [tab wasHidden];
+  [_toolbarController dismissTabHistoryPopup];
+}
+
+- (void)tabWasAdded:(NSNotification*)notify {
+  Tab* tab = notify.userInfo[kTabModelTabKey];
+  DCHECK(tab);
+
+  // Update map if a native controller was vended before the tab was added.
+  id<CRWNativeContent> nativeController =
+      [_nativeControllersForTabIDs objectForKey:kNativeControllerTemporaryKey];
+  if (nativeController) {
+    [_nativeControllersForTabIDs
+        removeObjectForKey:kNativeControllerTemporaryKey];
+    [_nativeControllersForTabIDs setObject:nativeController forKey:tab.tabId];
+  }
+
+  // When adding new tabs, check what kind of reminder infobar should
+  // be added to the new tab. Try to add only one of them.
+  // This check is done when a new tab is added either through the Tools Menu
+  // "New Tab" or through "New Tab" in Stack View Controller. This method
+  // is called after a new tab has added and finished initial navigation.
+  // If this is added earlier, the initial navigation may end up clearing
+  // the infobar(s) that are just added. See http://crbug/340250 for details.
+  [[UpgradeCenter sharedInstance] addInfoBarToManager:[tab infoBarManager]
+                                             forTabId:[tab tabId]];
+  if (!ReSignInInfoBarDelegate::Create(_browserState, tab)) {
+    ios_internal::sync::displaySyncErrors(_browserState, tab);
+  }
+
+  // The rest of this function initiates the new tab animation, which is
+  // phone-specific.
+  if (IsIPadIdiom())
+    return;
+
+  // Do nothing if browsing is currently suspended.  The BVC will set everything
+  // up correctly when browsing resumes.
+  if (!self.visible || ![_model webUsageEnabled])
+    return;
+
+  BOOL inBackground = [notify.userInfo[kTabModelOpenInBackgroundKey] boolValue];
+
+  // Block that starts voice search at the end of new Tab animation if
+  // necessary.
+  ProceduralBlock startVoiceSearchIfNecessaryBlock = ^void() {
+    if (_startVoiceSearchAfterNewTabAnimation) {
+      _startVoiceSearchAfterNewTabAnimation = NO;
+      [self startVoiceSearch];
+    }
+  };
+
+  _inNewTabAnimation = YES;
+  if (!inBackground) {
+    UIView* animationParentView = _contentArea;
+    // Create the new page image, and load with the new tab page snapshot.
+    CGFloat newPageOffset = 0;
+    UIImageView* newPage;
+    if (tab.url == GURL(kChromeUINewTabURL) && !_isOffTheRecord &&
+        !IsIPadIdiom()) {
+      animationParentView = self.view;
+      newPage = [self pageFullScreenOpenCloseAnimationView];
+    } else {
+      newPage = [self pageOpenCloseAnimationView];
+    }
+    newPageOffset = newPage.frame.origin.y;
+
+    [tab view].frame = _contentArea.bounds;
+    newPage.image = [tab updateSnapshotWithOverlay:YES visibleFrameOnly:YES];
+    [animationParentView addSubview:newPage];
+    CGPoint origin = [self lastTapPoint];
+    ios_internal::page_animation_util::AnimateInPaperWithAnimationAndCompletion(
+        newPage, -newPageOffset,
+        newPage.frame.size.height - newPage.image.size.height, origin,
+        _isOffTheRecord, NULL, ^{
+          [newPage removeFromSuperview];
+          _inNewTabAnimation = NO;
+          // Only show |tab|'s view if it is the current tab in its TabModel.
+          // It is possible that the current Tab can be reset to a new value
+          // before the new Tab animation finished (e.g. if another Tab shows
+          // a dialog via |dialogPresenter|).
+          if ([_model currentTab] == tab)
+            [self tabSelected:tab];
+          startVoiceSearchIfNecessaryBlock();
+        });
+  } else {
+    // -updateSnapshotWithOverlay will force a screen redraw, so take the
+    // snapshot before adding the views needed for the background animation.
+    Tab* topTab = [_model currentTab];
+    UIImage* image = [topTab updateSnapshotWithOverlay:YES
+                                      visibleFrameOnly:self.isToolbarOnScreen];
+    // Add three layers in order on top of the contentArea for the animation:
+    // 1. The black "background" screen.
+    base::scoped_nsobject<UIView> background(
+        [[UIView alloc] initWithFrame:[_contentArea bounds]]);
+    InstallBackgroundInView(background);
+    [_contentArea addSubview:background];
+
+    // 2. A CardView displaying the data from the current tab.
+    CardView* topCard = [self addCardViewInFullscreen:!self.isToolbarOnScreen];
+    NSString* title = [topTab title];
+    if (![title length])
+      title = [topTab urlDisplayString];
+    [topCard setTitle:title];
+    [topCard setFavicon:[topTab favicon]];
+    [topCard setImage:image];
+
+    // 3. A new, blank CardView to represent the new tab being added.
+    // Launch the new background tab animation.
+    ios_internal::page_animation_util::AnimateNewBackgroundPageWithCompletion(
+        topCard, [_contentArea frame], IsPortrait(), ^{
+          [background removeFromSuperview];
+          [topCard removeFromSuperview];
+          _inNewTabAnimation = NO;
+          // Resnapshot the top card if it has its own toolbar, as the toolbar
+          // will be captured in the new tab animation, but isn't desired for
+          // the stack view snapshots.
+          id nativeController = [self nativeControllerForTab:topTab];
+          if ([nativeController conformsToProtocol:@protocol(ToolbarOwner)])
+            [topTab updateSnapshotWithOverlay:YES visibleFrameOnly:YES];
+          startVoiceSearchIfNecessaryBlock();
+        });
+  }
+}
+
+#pragma mark - UI Configuration and Layout
+
+- (void)updateWithTabModel:(TabModel*)model
+              browserState:(ios::ChromeBrowserState*)browserState {
+  DCHECK(model);
+  DCHECK(browserState);
+  DCHECK(!_model);
+  DCHECK(!_browserState);
+  _browserState = browserState;
+  _isOffTheRecord = browserState->IsOffTheRecord() ? YES : NO;
+  _model.reset([model retain]);
+  [_model addObserver:self];
+
+  if (!_isOffTheRecord) {
+    [DefaultIOSWebViewFactory
+        registerWebViewFactory:[ChromeWebViewFactory class]];
+  }
+  NSUInteger count = [_model count];
+  for (NSUInteger index = 0; index < count; ++index)
+    [self installDelegatesForTab:[_model tabAtIndex:index]];
+
+  [self registerForNotifications];
+
+  _imageFetcher->SetRequestContextGetter(_browserState->GetRequestContext());
+  _dominantColorCache.reset([[NSMutableDictionary alloc] init]);
+
+  // Register for bookmark changed notification.
+  _bookmarkModelBridge.reset(new BrowserBookmarkModelBridge(self));
+  _bookmarkModel = ios::BookmarkModelFactory::GetForBrowserState(_browserState);
+  _bookmarkModel->AddObserver(_bookmarkModelBridge.get());
+}
+
+- (void)ensureViewCreated {
+  ignore_result([self view]);
+}
+
+- (void)browserStateDestroyed {
+  [self setActive:NO];
+  // Reset the toolbar opacity in case it was changed for contextual search.
+  [self updateToolbarControlsAlpha:1.0];
+  [self updateToolbarBackgroundAlpha:1.0];
+  [_contextualSearchController close];
+  _contextualSearchController.reset();
+  [_contextualSearchPanel removeFromSuperview];
+  [_contextualSearchMask removeFromSuperview];
+  [_paymentRequestManager close];
+  _paymentRequestManager.reset();
+  BrowserListIOS::RemoveBrowser(self);
+  [_toolbarController browserStateDestroyed];
+  [_model browserStateDestroyed];
+  // The file remover needs the browser state, so needs to be destroyed now.
+  _externalFileRemover.reset();
+  _browserState = nullptr;
+}
+
+- (void)installFakeStatusBar {
+  if (IsIPadIdiom()) {
+    CGFloat statusBarHeight = StatusBarHeight();
+    CGRect statusBarFrame =
+        CGRectMake(0, 0, [[self view] frame].size.width, statusBarHeight);
+    base::scoped_nsobject<UIView> statusBarView(
+        [[UIView alloc] initWithFrame:statusBarFrame]);
+    [statusBarView setBackgroundColor:TabStrip::BackgroundColor()];
+    [statusBarView setAutoresizingMask:UIViewAutoresizingFlexibleWidth];
+    [statusBarView layer].zPosition = 99;
+    [[self view] addSubview:statusBarView];
+  }
+
+  // Add a white bar on phone so that the status bar on the NTP is white.
+  if (!IsIPadIdiom()) {
+    CGFloat statusBarHeight = StatusBarHeight();
+    CGRect statusBarFrame =
+        CGRectMake(0, 0, [[self view] frame].size.width, statusBarHeight);
+    base::scoped_nsobject<UIView> statusBarView(
+        [[UIView alloc] initWithFrame:statusBarFrame]);
+    [statusBarView setBackgroundColor:[UIColor whiteColor]];
+    [statusBarView setAutoresizingMask:UIViewAutoresizingFlexibleWidth];
+    [self.view insertSubview:statusBarView atIndex:0];
+  }
+}
+
+// Create the UI elements.  May or may not have valid browser state & tab model.
+- (void)buildToolbarAndTabStrip {
+  DCHECK([self isViewLoaded]);
+  DCHECK(!_toolbarModelDelegate);
+
+  // Create the preload controller before the toolbar controller.
+  if (!_preloadController) {
+    _preloadController.reset([_dependencyFactory newPreloadController]);
+    [_preloadController setDelegate:self];
+  }
+
+  // Create the toolbar model and controller.
+  _toolbarModelDelegate.reset(new ToolbarModelDelegateIOS(_model));
+  _toolbarModelIOS.reset([_dependencyFactory
+      newToolbarModelIOSWithDelegate:_toolbarModelDelegate.get()]);
+  _toolbarController.reset([_dependencyFactory
+      newWebToolbarControllerWithDelegate:self
+                                urlLoader:self
+                          preloadProvider:_preloadController.get()]);
+  [_toolbarController setTabCount:[_model count]];
+  if (_voiceSearchController.get())
+    _voiceSearchController->SetDelegate(_toolbarController);
+
+  // If needed, create the tabstrip.
+  if (IsIPadIdiom()) {
+    // Determine if it's incognito. Whether or not the toggle button is
+    // visible is consolidated in logic elsewhere so it doesn't need to be set
+    // here.
+    _tabStripController.reset(
+        [_dependencyFactory newTabStripControllerWithTabModel:_model]);
+    _tabStripController.get().fullscreenDelegate = self;
+    [_tabStripController setHasTabSwitcherToggleSwitch:
+                             experimental_flags::IsTabSwitcherEnabled()];
+
+    // If set before the views are loaded, pass the mode toggle to the
+    // toolbar controller (only needed if YES, defaults to NO).
+    if (_modeToggleNeedsSetting) {
+      _tabStripController.get().hasModeToggleSwitch = _modeToggleNeedsSetting;
+    }
+  }
+
+  // Create infobar container.
+  if (!_infoBarContainerDelegate) {
+    _infoBarContainerDelegate.reset(new InfoBarContainerDelegateIOS(self));
+    _infoBarContainer.reset(
+        new InfoBarContainerIOS(_infoBarContainerDelegate.get()));
+  }
+}
+
+// Enable functionality that only makes sense if the views are loaded and
+// both browser state and tab model are valid.
+- (void)addUIFunctionalityForModelAndBrowserState {
+  DCHECK(_browserState);
+  DCHECK(_model);
+  DCHECK([self isViewLoaded]);
+
+  [self.sideSwipeController addHorizontalGesturesToView:self.view];
+
+  infobars::InfoBarManager* infoBarManager =
+      [[_model currentTab] infoBarManager];
+  _infoBarContainer->ChangeInfoBarManager(infoBarManager);
+
+  // Create contextual search views and controller.
+  if ([TouchToSearchPermissionsMediator isTouchToSearchAvailableOnDevice] &&
+      !_browserState->IsOffTheRecord()) {
+    _contextualSearchMask =
+        [[[ContextualSearchMaskView alloc] init] autorelease];
+    [self.view insertSubview:_contextualSearchMask
+                belowSubview:[_toolbarController view]];
+    _contextualSearchPanel = [self createPanelView];
+    [self.view insertSubview:_contextualSearchPanel
+                aboveSubview:[_toolbarController view]];
+    _contextualSearchController.reset([[ContextualSearchController alloc]
+        initWithBrowserState:_browserState
+                    delegate:self]);
+    [_contextualSearchController setPanel:_contextualSearchPanel];
+    [_contextualSearchController setTab:[_model currentTab]];
+  }
+
+  if (experimental_flags::IsPaymentRequestEnabled()) {
+    _paymentRequestManager.reset([[PaymentRequestManager alloc]
+        initWithBaseViewController:self
+                      browserState:_browserState]);
+    [_paymentRequestManager setWebState:[_model currentTab].webState];
+  }
+}
+
+// Set the frame for the various views. View must be loaded.
+- (void)setUpViewLayout {
+  DCHECK([self isViewLoaded]);
+
+  CGFloat widthOfView = CGRectGetWidth([self view].bounds);
+
+  CGFloat minY = [self headerOffset];
+
+  // If needed, position the tabstrip.
+  if (IsIPadIdiom()) {
+    [self layoutTabStripForWidth:widthOfView];
+    [[self view] addSubview:[_tabStripController view]];
+    minY += CGRectGetHeight([[_tabStripController view] frame]);
+  }
+
+  // Position the toolbar next, either at the top of the browser view or
+  // directly under the tabstrip.
+  CGRect toolbarFrame = [[_toolbarController view] frame];
+  toolbarFrame.origin = CGPointMake(0, minY);
+  toolbarFrame.size.width = widthOfView;
+  [[_toolbarController view] setFrame:toolbarFrame];
+
+  // Place the infobar container above the content area.
+  InfoBarContainerView* infoBarContainerView = _infoBarContainer->view();
+  [self.view insertSubview:infoBarContainerView aboveSubview:_contentArea];
+
+  // Place the toolbar controller above the infobar container.
+  [[self view] insertSubview:[_toolbarController view]
+                aboveSubview:infoBarContainerView];
+  minY += CGRectGetHeight(toolbarFrame);
+
+  // Account for the toolbar's drop shadow.  The toolbar overlaps with the web
+  // content slightly.
+  minY -= [ToolbarController toolbarDropShadowHeight];
+
+  // Adjust the content area to be under the toolbar, for fullscreen or below
+  // the toolbar is not fullscreen.
+  CGRect contentFrame = [_contentArea frame];
+  CGFloat marginWithHeader = StatusBarHeight();
+  CGFloat overlap = [self headerHeight] != 0 ? marginWithHeader : minY;
+  contentFrame.size.height = CGRectGetMaxY(contentFrame) - overlap;
+  contentFrame.origin.y = overlap;
+  [_contentArea setFrame:contentFrame];
+
+  // Adjust the infobar container to be either at the bottom of the screen
+  // (iPhone) or on the lower toolbar edge (iPad).
+  CGRect infoBarFrame = contentFrame;
+  infoBarFrame.origin.y = CGRectGetMaxY(contentFrame);
+  infoBarFrame.size.height = 0;
+  [infoBarContainerView setFrame:infoBarFrame];
+
+  // Attach the typing shield to the content area but have it hidden.
+  [_typingShield setFrame:[_contentArea frame]];
+  [[self view] insertSubview:_typingShield aboveSubview:_contentArea];
+  [_typingShield setHidden:YES];
+  _typingShield.accessibilityIdentifier = @"Typing Shield";
+  _typingShield.accessibilityLabel = l10n_util::GetNSString(IDS_CANCEL);
+}
+
+- (void)layoutTabStripForWidth:(CGFloat)maxWidth {
+  UIView* tabStripView = [_tabStripController view];
+  CGRect tabStripFrame = [tabStripView frame];
+  tabStripFrame.origin = CGPointZero;
+  // TODO(crbug.com/256655): Move the origin.y below to -setUpViewLayout.
+  // because the CGPointZero above will break reset the offset, but it's not
+  // clear what removing that will do.
+  tabStripFrame.origin.y = [self headerOffset];
+  tabStripFrame.size.width = maxWidth;
+  [tabStripView setFrame:tabStripFrame];
+}
+
+- (void)displayTab:(Tab*)tab isNewSelection:(BOOL)newSelection {
+  DCHECK(tab);
+  // Ensure that self.view is loaded to avoid errors that can otherwise occur
+  // when accessing |_contentArea| below.
+  if (!_contentArea)
+    [self ensureViewCreated];
+
+  DCHECK(_contentArea);
+  if (!_inNewTabAnimation) {
+    // Hide findbar.  |updateToolbar| will restore the findbar later.
+    [self hideFindBarWithAnimation:NO];
+
+    // Make new content visible, resizing it first as the orientation may
+    // have changed from the last time it was displayed.
+    [[tab view] setFrame:_contentArea.bounds];
+    [_contentArea displayContentView:[tab view]];
+  }
+  [self updateToolbar];
+
+  if (newSelection)
+    [_toolbarController selectedTabChanged];
+
+  // Notify the Tab that it was displayed.
+  [tab wasShown];
+}
+
+- (void)initializeBookmarkInteractionController {
+  if (_bookmarkInteractionController)
+    return;
+  _bookmarkInteractionController.reset([[BookmarkInteractionController alloc]
+      initWithBrowserState:_browserState
+                    loader:self
+          parentController:self]);
+}
+
+// Update the state of back and forward buttons, hiding the forward button if
+// there is nowhere to go. Assumes the model's current tab is up to date.
+- (void)updateToolbar {
+  // If the BVC has been partially torn down for low memory, wait for the
+  // view rebuild to handle toolbar updates.
+  if (!(_toolbarModelIOS && _browserState))
+    return;
+
+  Tab* tab = [_model currentTab];
+  if (![tab navigationManager])
+    return;
+  [_toolbarController updateToolbarState];
+  [_toolbarController setShareButtonEnabled:self.canShowShareMenu];
+
+  if (tab.isPrerenderTab && !_toolbarModelIOS->IsLoading())
+    [_toolbarController showPrerenderingAnimation];
+
+  // Also update the loading state for the tools menu (that is really an
+  // extension of the toolbar on the iPhone).
+  if (!IsIPadIdiom())
+    [[_toolbarController toolsPopupController]
+        setIsTabLoading:_toolbarModelIOS->IsLoading()];
+
+  if (tab.findInPageController.findInPageModel.enabled)
+    [self showFindBarWithAnimation:NO
+                        selectText:YES
+                       shouldFocus:[_findBarController isFocused]];
+
+  // Hide the toolbar if displaying phone NTP.
+  if (!IsIPadIdiom()) {
+    CRWSessionEntry* entry =
+        [[tab navigationManager]->GetSessionController() currentEntry];
+    BOOL hideToolbar = NO;
+    if (entry) {
+      GURL url = [entry navigationItem]->GetURL();
+      BOOL isNTP = url.GetOrigin() == GURL(kChromeUINewTabURL);
+      hideToolbar = isNTP && !_isOffTheRecord &&
+                    ![_toolbarController isOmniboxFirstResponder] &&
+                    ![_toolbarController showingOmniboxPopup];
+    }
+    [[_toolbarController view] setHidden:hideToolbar];
+  }
+}
+
+- (void)updateDialogPresenterActiveState {
+  self.dialogPresenter.active = self.active && self.viewVisible;
+}
+
+- (void)dismissPopups {
+  if (_noTabsController.get())
+    [_noTabsController dismissToolsMenuPopup];
+  else
+    [_toolbarController dismissToolsMenuPopup];
+  [self hidePageInfoPopupForView:nil];
+  [_toolbarController dismissTabHistoryPopup];
+  [[_model currentTab].webController recordStateInHistory];
+}
+
+#pragma mark - Tap handling
+
+- (void)setLastTapPoint:(id)sender {
+  CGPoint center;
+  UIView* parentView = nil;
+  if ([sender isKindOfClass:[UIView class]]) {
+    center = [sender center];
+    parentView = [sender superview];
+  }
+  if ([sender isKindOfClass:[ToolsMenuViewItem class]]) {
+    parentView = [[sender tableViewCell] superview];
+    center = [[sender tableViewCell] center];
+  }
+
+  if (parentView) {
+    _lastTapPoint = [parentView convertPoint:center toView:self.view];
+    _lastTapTime = CACurrentMediaTime();
+  }
+}
+
+- (CGPoint)lastTapPoint {
+  if (CACurrentMediaTime() - _lastTapTime < 1) {
+    return _lastTapPoint;
+  }
+  return CGPointZero;
+}
+
+- (void)saveContentAreaTapLocation:(UIGestureRecognizer*)gestureRecognizer {
+  UIView* view = gestureRecognizer.view;
+  CGPoint viewCoordinate = [gestureRecognizer locationInView:view];
+  _lastTapPoint =
+      [[view superview] convertPoint:viewCoordinate toView:self.view];
+  _lastTapTime = CACurrentMediaTime();
+}
+
+- (BOOL)addTabIfNoTabWithNormalBrowserState {
+  if (![_model count]) {
+    if (!_isOffTheRecord) {
+      [self addSelectedTabWithURL:GURL(kChromeUINewTabURL)
+                       transition:ui::PAGE_TRANSITION_TYPED];
+      return YES;
+    }
+  }
+  return NO;
+}
+
+#pragma mark - Tab creation and selection
+
+// Called when either a tab finishes loading or when a tab with finished content
+// is added directly to the model via pre-rendering.
+- (void)tabLoadComplete:(Tab*)tab withSuccess:(BOOL)success {
+  DCHECK(tab && ([_model indexOfTab:tab] != NSNotFound));
+
+  // Persist the session on a delay.
+  [_model saveSessionImmediately:NO];
+}
+
+- (Tab*)addSelectedTabWithURL:(const GURL&)url
+                     postData:(TemplateURLRef::PostContent*)postData
+                   transition:(ui::PageTransition)transition {
+  return [self addSelectedTabWithURL:url
+                            postData:postData
+                             atIndex:[_model count]
+                          transition:transition];
+}
+
+- (Tab*)addSelectedTabWithURL:(const GURL&)url
+                   transition:(ui::PageTransition)transition {
+  return [self addSelectedTabWithURL:url
+                             atIndex:[_model count]
+                          transition:transition];
+}
+
+- (Tab*)addSelectedTabWithURL:(const GURL&)url
+                      atIndex:(NSUInteger)position
+                   transition:(ui::PageTransition)transition {
+  return [self addSelectedTabWithURL:url
+                            postData:NULL
+                             atIndex:position
+                          transition:transition];
+}
+
+- (Tab*)addSelectedTabWithURL:(const GURL&)URL
+                     postData:(TemplateURLRef::PostContent*)postData
+                      atIndex:(NSUInteger)position
+                   transition:(ui::PageTransition)transition {
+  if (position == NSNotFound)
+    position = [_model count];
+  DCHECK(position <= [_model count]);
+
+  web::NavigationManager::WebLoadParams params(URL);
+  params.transition_type = transition;
+  if (postData) {
+    // Extract the content type and post params from |postData| and add them
+    // to the load params.
+    NSString* contentType = base::SysUTF8ToNSString(postData->first);
+    NSData* data = [NSData dataWithBytes:(void*)postData->second.data()
+                                  length:postData->second.length()];
+    params.post_data.reset([data retain]);
+    params.extra_headers.reset([@{ @"Content-Type" : contentType } retain]);
+  }
+  Tab* tab = [_model insertOrUpdateTabWithLoadParams:params
+                                          windowName:nil
+                                              opener:nil
+                                         openedByDOM:NO
+                                             atIndex:position
+                                        inBackground:NO];
+  return tab;
+}
+
+// Whether the given tab's url begins with the chrome prefix.
+- (BOOL)isTabNativePage:(Tab*)tab {
+  return tab && tab.url.SchemeIs(kChromeUIScheme);
+}
+
+- (void)expectNewForegroundTab {
+  _expectingForegroundTab = YES;
+}
+
+- (UIImageView*)pageFullScreenOpenCloseAnimationView {
+  CGRect viewBounds, remainder;
+  CGRectDivide(self.view.bounds, &remainder, &viewBounds, StatusBarHeight(),
+               CGRectMinYEdge);
+  return [[[UIImageView alloc] initWithFrame:viewBounds] autorelease];
+}
+
+- (UIImageView*)pageOpenCloseAnimationView {
+  CGRect frame = [_contentArea bounds];
+
+  frame.size.height = frame.size.height - [self headerHeight];
+  frame.origin.y = [self headerHeight];
+
+  UIImageView* pageView =
+      [[[UIImageView alloc] initWithFrame:frame] autorelease];
+  CGPoint center = CGPointMake(CGRectGetMidX(frame), CGRectGetMidY(frame));
+  pageView.center = center;
+
+  pageView.backgroundColor = [UIColor whiteColor];
+  return pageView;
+}
+
+- (void)installDelegatesForTab:(Tab*)tab {
+  // We don't unregister any of this delegation.
+  // TODO(crbug.com/375577): Unregister these delegates correctly on BVC
+  // deallocation.
+  tab.dialogDelegate = self;
+  tab.snapshotOverlayProvider = self;
+  tab.storeKitLauncher = self;
+  tab.passKitDialogProvider = self;
+  tab.fullScreenControllerDelegate = self;
+  if (!IsIPadIdiom()) {
+    tab.overscrollActionsControllerDelegate = self;
+  }
+  tab.tabSnapshottingDelegate = self;
+  // Install the proper CRWWebController delegates.
+  tab.webController.nativeProvider = self;
+  tab.webController.swipeRecognizerProvider = self.sideSwipeController;
+  // Delegate will remove itself on destruction.
+  tab.webState->SetDelegate(_webStateDelegate.get());
+}
+
+// Called when a tab is selected in the model. Make any required view changes.
+// The notification will not be sent when the tab is already the selected tab.
+- (void)tabSelected:(Tab*)tab {
+  DCHECK(tab);
+
+  // Ignore changes while the tab stack view is visible (or while suspended).
+  // The display will be refreshed when this view becomes active again.
+  if (!self.visible || ![_model webUsageEnabled])
+    return;
+
+  [self displayTab:tab isNewSelection:YES];
+
+  if (_expectingForegroundTab && !_inNewTabAnimation) {
+    // Now that the new tab has been displayed, return to normal. Rather than
+    // keep a reference to the previous tab, just turn off preview mode for all
+    // tabs (since doing so is a no-op for the tabs that don't have it set).
+    _expectingForegroundTab = NO;
+    for (Tab* tab in _model.get()) {
+      [tab.webController setOverlayPreviewMode:NO];
+    }
+  }
+}
+
+#pragma mark - External files
+
+- (NSSet*)referencedExternalFiles {
+  NSSet* filesReferencedByTabs = [_model currentlyReferencedExternalFiles];
+
+  // TODO(noyau): this is incorrect, the caller should know that the model is
+  // not loaded yet.
+  if (!_bookmarkModel->loaded())
+    return filesReferencedByTabs;
+
+  std::vector<bookmarks::BookmarkModel::URLAndTitle> bookmarks;
+  _bookmarkModel->GetBookmarks(&bookmarks);
+  NSMutableSet* bookmarkedFiles = [NSMutableSet set];
+  for (const auto& bookmark : bookmarks) {
+    GURL bookmarkUrl = bookmark.url;
+    if (UrlIsExternalFileReference(bookmarkUrl)) {
+      [bookmarkedFiles
+          addObject:base::SysUTF8ToNSString(bookmarkUrl.ExtractFileName())];
+    }
+  }
+  return [filesReferencedByTabs setByAddingObjectsFromSet:bookmarkedFiles];
+}
+
+- (void)removeExternalFilesImmediately:(BOOL)immediately
+                     completionHandler:(ProceduralBlock)completionHandler {
+  DCHECK_CURRENTLY_ON(web::WebThread::UI);
+  DCHECK(!_isOffTheRecord);
+  _externalFileRemover.reset(new ExternalFileRemover(self));
+  // Delay the cleanup of the unreferenced files received from other apps
+  // to not impact startup performance.
+  int delay = immediately ? 0 : kExternalFilesCleanupDelaySeconds;
+  _externalFileRemover->RemoveAfterDelay(
+      base::TimeDelta::FromSeconds(delay),
+      base::BindBlock(completionHandler ? completionHandler
+                                        : ^{
+                                          }));
+}
+
+#pragma mark - SnapshotOverlayProvider methods
+
+- (NSArray*)snapshotOverlaysForTab:(Tab*)tab {
+  NSMutableArray* overlays = [NSMutableArray array];
+  if (![_model webUsageEnabled]) {
+    return overlays;
+  }
+  UIView* voiceSearchView = [self voiceSearchOverlayViewForTab:tab];
+  if (voiceSearchView) {
+    CGFloat voiceSearchYOffset = [self voiceSearchOverlayYOffsetForTab:tab];
+    base::scoped_nsobject<SnapshotOverlay> voiceSearchOverlay(
+        [[SnapshotOverlay alloc] initWithView:voiceSearchView
+                                      yOffset:voiceSearchYOffset]);
+    [overlays addObject:voiceSearchOverlay];
+  }
+  UIView* infoBarView = [self infoBarOverlayViewForTab:tab];
+  if (infoBarView) {
+    CGFloat infoBarYOffset = [self infoBarOverlayYOffsetForTab:tab];
+    base::scoped_nsobject<SnapshotOverlay> infoBarOverlay(
+        [[SnapshotOverlay alloc] initWithView:infoBarView
+                                      yOffset:infoBarYOffset]);
+    [overlays addObject:infoBarOverlay];
+  }
+  return overlays;
+}
+
+#pragma mark -
+
+- (UIView*)infoBarOverlayViewForTab:(Tab*)tab {
+  if (IsIPadIdiom()) {
+    // Not using overlays on iPad because the content is pushed down by
+    // infobar and the transition between snapshot and fresh page can
+    // cause both snapshot and real infobars to appear at the same time.
+    return nil;
+  }
+  Tab* currentTab = [_model currentTab];
+  if (tab && tab == currentTab) {
+    infobars::InfoBarManager* infoBarManager = [currentTab infoBarManager];
+    if (infoBarManager->infobar_count() > 0) {
+      DCHECK(_infoBarContainer);
+      return _infoBarContainer->view();
+    }
+  }
+  return nil;
+}
+
+- (CGFloat)infoBarOverlayYOffsetForTab:(Tab*)tab {
+  if (tab != [_model currentTab] || !_infoBarContainer.get()) {
+    // There is no UI representation for non-current tabs or there is
+    // no _infoBarContainer instantiated yet.
+    // Return offset outside of tab.
+    return CGRectGetMaxY(self.view.frame);
+  } else if (IsIPadIdiom()) {
+    // The infobars on iPad are display at the top of a tab.
+    return CGRectGetMinY([[_model currentTab].webController visibleFrame]);
+  } else {
+    // The infobars on iPhone are displayed at the bottom of a tab.
+    CGRect visibleFrame = [[_model currentTab].webController visibleFrame];
+    return CGRectGetMaxY(visibleFrame) -
+           CGRectGetHeight(_infoBarContainer->view().frame);
+  }
+}
+
+- (UIView*)voiceSearchOverlayViewForTab:(Tab*)tab {
+  Tab* currentTab = [_model currentTab];
+  if (tab && tab == currentTab && tab.isVoiceSearchResultsTab &&
+      _voiceSearchBar && ![_voiceSearchBar isHidden]) {
+    return _voiceSearchBar;
+  }
+  return nil;
+}
+
+- (CGFloat)voiceSearchOverlayYOffsetForTab:(Tab*)tab {
+  if (tab != [_model currentTab] || [_voiceSearchBar isHidden]) {
+    // There is no UI representation for non-current tabs or there is
+    // no visible voice search. Return offset outside of tab.
+    return CGRectGetMaxY(self.view.frame);
+  } else {
+    // The voice search bar on iPhone is displayed at the bottom of a tab.
+    CGRect visibleFrame = [[_model currentTab].webController visibleFrame];
+    return CGRectGetMaxY(visibleFrame) - kVoiceSearchBarHeight;
+  }
+}
+
+- (void)ensureVoiceSearchControllerCreated {
+  if (!_voiceSearchController.get()) {
+    VoiceSearchProvider* provider =
+        ios::GetChromeBrowserProvider()->GetVoiceSearchProvider();
+    if (provider) {
+      _voiceSearchController =
+          provider->CreateVoiceSearchController(_browserState);
+      _voiceSearchController->SetDelegate(_toolbarController);
+    }
+  }
+}
+
+- (void)ensureVoiceSearchBarCreated {
+  if (_voiceSearchBar)
+    return;
+
+  CGFloat width = CGRectGetWidth([[self view] bounds]);
+  CGFloat y = CGRectGetHeight([[self view] bounds]) - kVoiceSearchBarHeight;
+  CGRect frame = CGRectMake(0.0, y, width, kVoiceSearchBarHeight);
+  _voiceSearchBar.reset(ios::GetChromeBrowserProvider()
+                            ->GetVoiceSearchProvider()
+                            ->CreateVoiceSearchBar(frame));
+  [_voiceSearchBar setVoiceSearchBarDelegate:self];
+  [_voiceSearchBar setHidden:YES];
+  [_voiceSearchBar setAutoresizingMask:UIViewAutoresizingFlexibleTopMargin |
+                                       UIViewAutoresizingFlexibleWidth];
+  [self.view insertSubview:_voiceSearchBar
+              belowSubview:_infoBarContainer->view()];
+}
+
+- (void)updateVoiceSearchBarVisibilityAnimated:(BOOL)animated {
+  // Voice search bar exists and is shown/hidden.
+  BOOL show = self.shouldShowVoiceSearchBar;
+  if (_voiceSearchBar && _voiceSearchBar.get().hidden != show)
+    return;
+
+  // Voice search bar doesn't exist and thus is not visible.
+  if (!_voiceSearchBar && !show)
+    return;
+
+  if (animated)
+    [_voiceSearchBar.get() animateToBecomeVisible:show];
+  else
+    _voiceSearchBar.get().hidden = !show;
+}
+
+- (id<LogoAnimationControllerOwner>)currentLogoAnimationControllerOwner {
+  Protocol* ownerProtocol = @protocol(LogoAnimationControllerOwner);
+  if ([_voiceSearchBar conformsToProtocol:ownerProtocol] &&
+      self.shouldShowVoiceSearchBar) {
+    // Use |_voiceSearchBar| for VoiceSearch results tab and dismissal
+    // animations.
+    return static_cast<id<LogoAnimationControllerOwner>>(_voiceSearchBar.get());
+  }
+  id currentNativeController =
+      [self nativeControllerForTab:self.tabModel.currentTab];
+  Protocol* possibleOwnerProtocol =
+      @protocol(LogoAnimationControllerOwnerOwner);
+  if ([currentNativeController conformsToProtocol:possibleOwnerProtocol] &&
+      [currentNativeController logoAnimationControllerOwner]) {
+    // If the current native controller is showing a GLIF view (e.g. the NTP
+    // when there is no doodle), use that GLIFControllerOwner.
+    return [currentNativeController logoAnimationControllerOwner];
+  }
+  return nil;
+}
+
+#pragma mark - PassKitDialogProvider methods
+
+- (void)presentPassKitDialog:(NSData*)data {
+  NSError* error = nil;
+  base::scoped_nsobject<PKPass> pass;
+  if (data)
+    pass.reset([[PKPass alloc] initWithData:data error:&error]);
+  if (error || !data) {
+    if ([_model currentTab]) {
+      infobars::InfoBarManager* infoBarManager =
+          [[_model currentTab] infoBarManager];
+      // TODO(crbug.com/227994): Infobar cleanup (infoBarManager should never be
+      //            NULL, replace if with DCHECK).
+      if (infoBarManager)
+        [_dependencyFactory showPassKitErrorInfoBarForManager:infoBarManager];
+    }
+  } else {
+    PKAddPassesViewController* passKitViewController =
+        [_dependencyFactory newPassKitViewControllerForPass:pass];
+    if (passKitViewController) {
+      [self presentViewController:passKitViewController
+                         animated:YES
+                       completion:^{
+                       }];
+    }
+  }
+}
+
+- (UIStatusBarStyle)preferredStatusBarStyle {
+  return (IsIPadIdiom() || _isOffTheRecord) ? UIStatusBarStyleLightContent
+                                            : UIStatusBarStyleDefault;
+}
+
+#pragma mark - CRWWebStateDelegate methods.
+
+- (void)webState:(web::WebState*)webState didChangeProgress:(double)progress {
+  if (webState == [_model currentTab].webState) {
+    // TODO(crbug.com/546406): It is probably possible to do something smarter,
+    // but the fact that this is not always sent will have to be taken into
+    // account.
+    [self updateToolbar];
+  }
+}
+
+- (BOOL)webState:(web::WebState*)webState
+    handleContextMenu:(const web::ContextMenuParams&)params {
+  // Prevent context menu from displaying for a tab which is no longer the
+  // current one.
+  if (webState != [_model currentTab].webState) {
+    return NO;
+  }
+
+  // No custom context menu if no valid url is available in |params|.
+  if (!params.link_url.is_valid() && !params.src_url.is_valid()) {
+    return NO;
+  }
+
+  DCHECK(_browserState);
+  DCHECK([_model currentTab]);
+
+  _contextMenuCoordinator.reset([[ContextMenuCoordinator alloc]
+      initWithBaseViewController:self
+                          params:params]);
+
+  NSString* title = nil;
+  ProceduralBlock action = nil;
+
+  base::WeakNSObject<BrowserViewController> weakSelf(self);
+  GURL link = params.link_url;
+  bool isLink = link.is_valid();
+  GURL imageUrl = params.src_url;
+  bool isImage = imageUrl.is_valid();
+
+  if (isLink) {
+    if (link.SchemeIs(url::kJavaScriptScheme)) {
+      // Open
+      title = l10n_util::GetNSStringWithFixup(IDS_IOS_CONTENT_CONTEXT_OPEN);
+      action = ^{
+        Record(ACTION_OPEN_JAVASCRIPT, isImage, isLink);
+        [weakSelf openJavascript:base::SysUTF8ToNSString(link.GetContent())];
+      };
+      [_contextMenuCoordinator addItemWithTitle:title action:action];
+    }
+
+    if (web::UrlHasWebScheme(link)) {
+      web::Referrer referrer([_model currentTab].url, params.referrer_policy);
+
+      if (reading_list::switches::IsReadingListEnabled()) {
+        NSString* innerText = params.link_text;
+        if ([innerText length] > 0) {
+          // Add to reading list.
+          title = l10n_util::GetNSStringWithFixup(
+              IDS_IOS_CONTENT_CONTEXT_ADDTOREADINGLIST);
+          action = ^{
+            Record(ACTION_READ_LATER, isImage, isLink);
+            [weakSelf addToReadingListURL:link title:innerText];
+          };
+          [_contextMenuCoordinator addItemWithTitle:title action:action];
+        }
+      }
+
+      // Open in New Tab.
+      title = l10n_util::GetNSStringWithFixup(
+          IDS_IOS_CONTENT_CONTEXT_OPENLINKNEWTAB);
+      action = ^{
+        Record(ACTION_OPEN_IN_NEW_TAB, isImage, isLink);
+        [weakSelf webPageOrderedOpen:link
+                            referrer:referrer
+                          windowName:nil
+                        inBackground:YES
+                            appendTo:kCurrentTab];
+      };
+      [_contextMenuCoordinator addItemWithTitle:title action:action];
+      if (!_isOffTheRecord) {
+        // Open in Incognito Tab.
+        title = l10n_util::GetNSStringWithFixup(
+            IDS_IOS_CONTENT_CONTEXT_OPENLINKNEWINCOGNITOTAB);
+        action = ^{
+          Record(ACTION_OPEN_IN_INCOGNITO_TAB, isImage, isLink);
+          [weakSelf webPageOrderedOpen:link
+                              referrer:referrer
+                            windowName:nil
+                           inIncognito:YES
+                          inBackground:NO
+                              appendTo:kCurrentTab];
+        };
+        [_contextMenuCoordinator addItemWithTitle:title action:action];
+      }
+    }
+    // Copy Link.
+    title = l10n_util::GetNSStringWithFixup(IDS_IOS_CONTENT_CONTEXT_COPY);
+    action = ^{
+      Record(ACTION_COPY_LINK_ADDRESS, isImage, isLink);
+      NSURL* url = net::NSURLWithGURL(link);
+      NSDictionary* item = @{
+        (NSString*)kUTTypeURL : url,
+        (NSString*)kUTTypeUTF8PlainText :
+            [[url absoluteString] dataUsingEncoding:NSUTF8StringEncoding],
+      };
+      [[UIPasteboard generalPasteboard] setItems:@[ item ]];
+    };
+    [_contextMenuCoordinator addItemWithTitle:title action:action];
+  }
+  if (isImage) {
+    web::Referrer referrer([_model currentTab].url, params.referrer_policy);
+    // Save Image.
+    if (experimental_flags::IsDownloadRenamingEnabled()) {
+      title = l10n_util::GetNSStringWithFixup(
+          IDS_IOS_CONTENT_CONTEXT_DOWNLOADIMAGE);
+    } else {
+      title =
+          l10n_util::GetNSStringWithFixup(IDS_IOS_CONTENT_CONTEXT_SAVEIMAGE);
+    }
+    action = ^{
+      Record(ACTION_SAVE_IMAGE, isImage, isLink);
+      [weakSelf saveImageAtURL:imageUrl referrer:referrer];
+    };
+    [_contextMenuCoordinator addItemWithTitle:title action:action];
+    // Open Image.
+    title = l10n_util::GetNSStringWithFixup(IDS_IOS_CONTENT_CONTEXT_OPENIMAGE);
+    action = ^{
+      Record(ACTION_OPEN_IMAGE, isImage, isLink);
+      [weakSelf loadURL:imageUrl
+                   referrer:referrer
+                 transition:ui::PAGE_TRANSITION_LINK
+          rendererInitiated:YES];
+    };
+    [_contextMenuCoordinator addItemWithTitle:title action:action];
+    // Open Image In New Tab.
+    title = l10n_util::GetNSStringWithFixup(
+        IDS_IOS_CONTENT_CONTEXT_OPENIMAGENEWTAB);
+    action = ^{
+      Record(ACTION_OPEN_IMAGE_IN_NEW_TAB, isImage, isLink);
+      [weakSelf webPageOrderedOpen:imageUrl
+                          referrer:referrer
+                        windowName:nil
+                      inBackground:true
+                          appendTo:kCurrentTab];
+    };
+    [_contextMenuCoordinator addItemWithTitle:title action:action];
+
+    TemplateURLService* service =
+        ios::TemplateURLServiceFactory::GetForBrowserState(_browserState);
+    TemplateURL* defaultURL = service->GetDefaultSearchProvider();
+    if (defaultURL && !defaultURL->image_url().empty() &&
+        defaultURL->image_url_ref().IsValid(service->search_terms_data())) {
+      title = l10n_util::GetNSStringF(IDS_IOS_CONTEXT_MENU_SEARCHWEBFORIMAGE,
+                                      defaultURL->short_name());
+      action = ^{
+        Record(ACTION_SEARCH_BY_IMAGE, isImage, isLink);
+        [weakSelf searchByImageAtURL:imageUrl referrer:referrer];
+      };
+      [_contextMenuCoordinator addItemWithTitle:title action:action];
+    }
+  }
+
+  [_contextMenuCoordinator start];
+  return YES;
+}
+
+- (web::JavaScriptDialogPresenter*)javaScriptDialogPresenterForWebState:
+    (web::WebState*)webState {
+  return _javaScriptDialogPresenter.get();
+}
+
+#pragma mark - FullScreenControllerDelegate methods
+
+- (CGFloat)headerOffset {
+  if (IsIPadIdiom())
+    return StatusBarHeight();
+  return 0.0;
+}
+
+- (const std::vector<HeaderDefinition>)headerViews {
+  std::vector<HeaderDefinition> results;
+  if (![self isViewLoaded])
+    return results;
+
+  if (!IsIPadIdiom()) {
+    if ([_toolbarController view]) {
+      HeaderDefinition header = {
+          base::scoped_nsobject<UIView>([[_toolbarController view] retain]),
+          Hideable, [ToolbarController toolbarDropShadowHeight], 0.0,
+      };
+      results.push_back(header);
+    }
+  } else {
+    if ([_tabStripController view]) {
+      HeaderDefinition header = {
+          base::scoped_nsobject<UIView>([[_tabStripController view] retain]),
+          Hideable, 0.0, 0.0,
+      };
+      results.push_back(header);
+    }
+    if ([_toolbarController view]) {
+      HeaderDefinition header = {
+          base::scoped_nsobject<UIView>([[_toolbarController view] retain]),
+          Hideable, [ToolbarController toolbarDropShadowHeight], 0.0,
+      };
+      results.push_back(header);
+    }
+    if ([_findBarController view]) {
+      HeaderDefinition header = {
+          base::scoped_nsobject<UIView>([[_findBarController view] retain]),
+          Overlap, 0.0, kIPadFindBarOverlap,
+      };
+      results.push_back(header);
+    }
+  }
+  return results;
+}
+
+- (UIView*)footerView {
+  return _voiceSearchBar;
+}
+
+- (CGFloat)headerHeight {
+  return [self headerHeightForTab:[_model currentTab]];
+}
+
+- (CGFloat)headerHeightForTab:(Tab*)tab {
+  id nativeController = [self nativeControllerForTab:tab];
+  if ([nativeController conformsToProtocol:@protocol(ToolbarOwner)] &&
+      [nativeController respondsToSelector:@selector(toolbarHeight)] &&
+      [nativeController toolbarHeight] > 0.0 && !IsIPadIdiom()) {
+    // On iPhone, don't add any header height for ToolbarOwner native
+    // controllers when they're displaying their own toolbar.
+    return 0;
+  }
+
+  const std::vector<HeaderDefinition> views = [self headerViews];
+
+  CGFloat height = [self headerOffset];
+  for (const auto& header : views) {
+    if (header.view && header.behaviour == Hideable) {
+      height += CGRectGetHeight([header.view frame]) -
+                header.heightAdjustement - header.inset;
+    }
+  }
+
+  return height - StatusBarHeight();
+}
+
+- (BOOL)isTabWithIDCurrent:(NSString*)sessionID {
+  return self.visible &&
+         [sessionID isEqualToString:[[_model currentTab] currentSessionID]];
+}
+
+- (CGFloat)currentHeaderOffset {
+  const std::vector<HeaderDefinition> headers = [self headerViews];
+  if (!headers.size())
+    return 0.0;
+
+  // Prerender tab does not have a toolbar, return |headerHeight| as promised by
+  // API documentation.
+  if ([[[self tabModel] currentTab] isPrerenderTab])
+    return [self headerHeight];
+
+  UIView* topHeader = headers[0].view;
+  return -(topHeader.frame.origin.y - [self headerOffset]);
+}
+
+- (CGFloat)footerYForHeaderOffset:(CGFloat)headerOffset {
+  UIView* footer = [self footerView];
+  CGFloat headerHeight = [self headerHeight];
+  if (!footer || headerHeight == 0)
+    return 0.0;
+
+  CGFloat footerHeight = CGRectGetHeight(footer.frame);
+  CGFloat offset = headerOffset * footerHeight / headerHeight;
+  return std::ceil(CGRectGetHeight(self.view.bounds) - footerHeight + offset);
+}
+
+- (void)fullScreenController:(FullScreenController*)controller
+    headerAnimationCompleted:(BOOL)completed
+                      offset:(CGFloat)offset {
+  if (completed)
+    [controller setToolbarInsetsForHeaderOffset:offset forceUpdate:YES];
+}
+
+- (void)setFramesForHeaders:(const std::vector<HeaderDefinition>)headers
+                   atOffset:(CGFloat)headerOffset {
+  CGFloat height = [self headerOffset];
+  for (const auto& header : headers) {
+    CGRect frame = [header.view frame];
+    frame.origin.y = height - headerOffset - header.inset;
+    [header.view setFrame:frame];
+    if (header.behaviour != Overlap)
+      height += CGRectGetHeight(frame);
+  }
+}
+
+- (void)fullScreenController:(FullScreenController*)fullScreenController
+    drawHeaderViewFromOffset:(CGFloat)headerOffset
+                     animate:(BOOL)animate {
+  if ([_sideSwipeController inSwipe])
+    return;
+
+  CGRect footerFrame = CGRectZero;
+  UIView* footer = nil;
+  // Only animate the voice search bar if the tab is a voice search results tab.
+  if ([_model currentTab].isVoiceSearchResultsTab) {
+    footer = [self footerView];
+    footerFrame = footer.frame;
+    footerFrame.origin.y = [self footerYForHeaderOffset:headerOffset];
+  }
+
+  const std::vector<HeaderDefinition> headers = [self headerViews];
+  void (^block)(void) = ^{
+    [self setFramesForHeaders:headers atOffset:headerOffset];
+    footer.frame = footerFrame;
+  };
+  void (^completion)(BOOL) = ^(BOOL finished) {
+    [self fullScreenController:fullScreenController
+        headerAnimationCompleted:finished
+                          offset:headerOffset];
+  };
+  if (animate) {
+    [UIView animateWithDuration:ios_internal::kToolbarAnimationDuration
+                          delay:0.0
+                        options:UIViewAnimationOptionBeginFromCurrentState
+                     animations:block
+                     completion:completion];
+  } else {
+    block();
+    completion(YES);
+  }
+}
+
+- (void)fullScreenController:(FullScreenController*)fullScreenController
+    drawHeaderViewFromOffset:(CGFloat)headerOffset
+              onWebViewProxy:(id<CRWWebViewProxy>)webViewProxy
+     changeTopContentPadding:(BOOL)changeTopContentPadding
+           scrollingToOffset:(CGFloat)contentOffset {
+  DCHECK(webViewProxy);
+  if ([_sideSwipeController inSwipe])
+    return;
+
+  CGRect footerFrame;
+  UIView* footer = nil;
+  // Only animate the voice search bar if the tab is a voice search results tab.
+  if ([_model currentTab].isVoiceSearchResultsTab) {
+    footer = [self footerView];
+    footerFrame = footer.frame;
+    footerFrame.origin.y = [self footerYForHeaderOffset:headerOffset];
+  }
+
+  const std::vector<HeaderDefinition> headers = [self headerViews];
+  void (^block)(void) = ^{
+    [self setFramesForHeaders:headers atOffset:headerOffset];
+    footer.frame = footerFrame;
+    webViewProxy.scrollViewProxy.contentOffset = CGPointMake(
+        webViewProxy.scrollViewProxy.contentOffset.x, contentOffset);
+    if (changeTopContentPadding)
+      webViewProxy.topContentPadding = contentOffset;
+  };
+  void (^completion)(BOOL) = ^(BOOL finished) {
+    [self fullScreenController:fullScreenController
+        headerAnimationCompleted:finished
+                          offset:headerOffset];
+  };
+
+  [UIView animateWithDuration:ios_internal::kToolbarAnimationDuration
+                        delay:0.0
+                      options:UIViewAnimationOptionBeginFromCurrentState
+                   animations:block
+                   completion:completion];
+}
+
+#pragma mark - VoiceSearchBarOwner
+
+- (id<VoiceSearchBar>)voiceSearchBar {
+  return _voiceSearchBar;
+}
+
+#pragma mark - Install OverScrollActionController method.
+- (void)setOverScrollActionControllerToStaticNativeContent:
+    (StaticHtmlNativeContent*)nativeContent {
+  if (!IsIPadIdiom() && !FirstRun::IsChromeFirstRun()) {
+    OverscrollActionsController* controller =
+        [[[OverscrollActionsController alloc]
+            initWithScrollView:[nativeContent scrollView]] autorelease];
+    [[nativeContent scrollView] setDelegate:controller];
+    [controller setDelegate:self];
+    ios_internal::OverscrollStyle style =
+        _isOffTheRecord
+            ? ios_internal::OverscrollStyle::REGULAR_PAGE_INCOGNITO
+            : ios_internal::OverscrollStyle::REGULAR_PAGE_NON_INCOGNITO;
+    controller.style = style;
+    nativeContent.overscrollActionsController = controller;
+  }
+}
+
+#pragma mark - OverscrollActionsControllerDelegate methods.
+
+- (void)overscrollActionsController:(OverscrollActionsController*)controller
+                   didTriggerAction:(ios_internal::OverscrollAction)action {
+  switch (action) {
+    case ios_internal::OverscrollAction::NEW_TAB:
+      [self newTab:nil];
+      break;
+    case ios_internal::OverscrollAction::CLOSE_TAB:
+      [self closeCurrentTab];
+      break;
+    case ios_internal::OverscrollAction::REFRESH:
+      if ([[[_model currentTab] webController] loadPhase] ==
+          web::PAGE_LOADING) {
+        [[_model currentTab] stopLoading];
+      }
+      [[_model currentTab] reload];
+      break;
+    case ios_internal::OverscrollAction::NONE:
+      NOTREACHED();
+      break;
+  }
+}
+
+- (BOOL)shouldAllowOverscrollActions {
+  return YES;
+}
+
+- (UIView*)headerView {
+  return [_toolbarController view];
+}
+
+- (UIView*)toolbarSnapshotView {
+  return [[_toolbarController view] snapshotViewAfterScreenUpdates:NO];
+}
+
+- (CGFloat)overscrollActionsControllerHeaderInset:
+    (OverscrollActionsController*)controller {
+  if (controller == [[[self tabModel] currentTab] overscrollActionsController])
+    return [self headerHeight];
+  else
+    return 0;
+}
+
+- (CGFloat)overscrollHeaderHeight {
+  return [self headerHeight] + StatusBarHeight();
+}
+
+#pragma mark - TabSnapshottingDelegate methods.
+
+- (CGRect)snapshotContentAreaForTab:(Tab*)tab {
+  CGRect pageContentArea = _contentArea.bounds;
+  if ([_model webUsageEnabled])
+    pageContentArea = tab.view.bounds;
+  CGFloat headerHeight = [self headerHeightForTab:tab];
+  id nativeController = [self nativeControllerForTab:tab];
+  if ([nativeController respondsToSelector:@selector(toolbarHeight)])
+    headerHeight += [nativeController toolbarHeight];
+  UIEdgeInsets contentInsets = UIEdgeInsetsMake(headerHeight, 0.0, 0.0, 0.0);
+  return UIEdgeInsetsInsetRect(pageContentArea, contentInsets);
+}
+
+#pragma mark - NewTabPageObserver methods.
+
+- (void)selectedPanelDidChange {
+  [self updateToolbar];
+}
+
+#pragma mark - CRWNativeContentProvider methods
+
+- (id<CRWNativeContent>)controllerForURL:(const GURL&)url
+                               withError:(NSError*)error
+                                  isPost:(BOOL)isPost {
+  ErrorPageContent* errorPageContent =
+      [[[ErrorPageContent alloc] initWithLoader:self
+                                   browserState:self.browserState
+                                            url:url
+                                          error:error
+                                         isPost:isPost
+                                    isIncognito:_isOffTheRecord] autorelease];
+  [self setOverScrollActionControllerToStaticNativeContent:errorPageContent];
+  return errorPageContent;
+}
+
+- (BOOL)hasControllerForURL:(const GURL&)url {
+  std::string host(url.host());
+
+  return host == kChromeUINewTabHost || host == kChromeUIBookmarksHost ||
+         host == kChromeUITermsHost || host == kChromeUIOfflineHost;
+}
+
+- (id<CRWNativeContent>)controllerForURL:(const GURL&)url {
+  DCHECK(url.SchemeIs(kChromeUIScheme));
+
+  id<CRWNativeContent> nativeController = nil;
+  std::string url_host = url.host();
+  if (url_host == kChromeUINewTabHost || url_host == kChromeUIBookmarksHost) {
+    NewTabPageController* pageController =
+        [[[NewTabPageController alloc] initWithUrl:url
+                                            loader:self
+                                           focuser:_toolbarController
+                                       ntpObserver:self
+                                      browserState:_browserState
+                                        colorCache:_dominantColorCache
+                                webToolbarDelegate:self
+                                          tabModel:_model] autorelease];
+    pageController.swipeRecognizerProvider = self.sideSwipeController;
+
+    // Panel is always NTP for iPhone.
+    NewTabPage::PanelIdentifier panelType = NewTabPage::kMostVisitedPanel;
+
+    if (IsIPadIdiom()) {
+      // New Tab Page can have multiple panels. Each panel is addressable
+      // by a #fragment, e.g. chrome://newtab/#most_visited takes user to
+      // the Most Visited page, chrome://newtab/#bookmarks takes user to
+      // the Bookmark Manager, etc.
+      // The utility functions NewTabPage::IdentifierFromFragment() and
+      // FragmentFromIdentifier() map an identifier to/from a #fragment.
+      // If the URL is chrome://bookmarks, pre-select the #bookmarks panel
+      // without changing the URL since the URL may be chrome://bookmarks/#123.
+      // If the URL is chrome://newtab/, pre-select the panel based on the
+      // #fragment.
+      panelType = url_host == kChromeUIBookmarksHost
+                      ? NewTabPage::kBookmarksPanel
+                      : NewTabPage::IdentifierFromFragment(url.ref());
+    }
+    [pageController selectPanel:panelType];
+    nativeController = pageController;
+  } else if (url_host == kChromeUITermsHost) {
+    const std::string& filename = GetTermsOfServicePath();
+
+    StaticHtmlNativeContent* staticNativeController =
+        [[[StaticHtmlNativeContent alloc]
+            initWithResourcePathResource:base::SysUTF8ToNSString(filename)
+                                  loader:self
+                            browserState:_browserState
+                                     url:GURL(kChromeUITermsURL)] autorelease];
+    [self setOverScrollActionControllerToStaticNativeContent:
+              staticNativeController];
+    nativeController = staticNativeController;
+  } else if (url_host == kChromeUIOfflineHost) {
+    StaticHtmlNativeContent* staticNativeController =
+        [[[OfflinePageNativeContent alloc] initWithLoader:self
+                                             browserState:_browserState
+                                                 webState:[self currentWebState]
+                                                      URL:url] autorelease];
+    [self setOverScrollActionControllerToStaticNativeContent:
+              staticNativeController];
+    nativeController = staticNativeController;
+  } else if (url_host == kChromeUIExternalFileHost) {
+    // Return an instance of the |ExternalFileController| only if the file is
+    // still in the sandbox.
+    NSString* filePath = [ExternalFileController pathForExternalFileURL:url];
+    if ([[NSFileManager defaultManager] fileExistsAtPath:filePath]) {
+      nativeController = [[[ExternalFileController alloc]
+           initWithURL:url
+          browserState:_browserState] autorelease];
+    }
+  } else {
+    DCHECK(![self hasControllerForURL:url]);
+    // In any other case the PageNotAvailableController is returned.
+    nativeController =
+        [[[PageNotAvailableController alloc] initWithUrl:url] autorelease];
+    if (url_host == kChromeUIHistoryFrameHost) {
+      base::mac::ObjCCastStrict<PageNotAvailableController>(nativeController)
+          .descriptionText = l10n_util::GetNSStringFWithFixup(
+          IDS_IOS_HISTORY_URL_NOT_AVAILABLE,
+          base::UTF8ToUTF16(kChromeUIHistoryURL),
+          l10n_util::GetStringUTF16(IDS_HISTORY_SHOW_HISTORY));
+    }
+  }
+  // If a native controller is vended before its tab is added to the tab model,
+  // use the temporary key and add it under the new tab's tabId in the
+  // TabModelObserver callback.  This happens:
+  // - when there is no current tab (occurs when vending the NTP controller for
+  //   the first tab that is opened),
+  // - when the current tab's url doesn't match |url| (occurs when a native
+  //   controller is opened in a new tab)
+  // - when the current tab's url matches |url| and there is already a native
+  //   controller of the appropriate type vended to it (occurs when a native
+  //   controller is opened in a new tab from a tab with a matching URL, e.g.
+  //   opening an NTP when an NTP is already displayed in the current tab).
+  // For normal page loads, history navigations, tab restorations, and crash
+  // recoveries, the tab will already exist in the tab model and the tabId can
+  // be used as the native controller key.
+  // TODO(crbug.com/498568): To reduce complexity here, refactor the flow so
+  // that native controllers vended here always correspond to the current tab.
+  Tab* currentTab = [_model currentTab];
+  NSString* nativeControllerKey = currentTab.tabId;
+  if (!currentTab || currentTab.url != url ||
+      [[_nativeControllersForTabIDs objectForKey:nativeControllerKey]
+          isKindOfClass:[nativeController class]]) {
+    nativeControllerKey = kNativeControllerTemporaryKey;
+  }
+  DCHECK(nativeControllerKey);
+  [_nativeControllersForTabIDs setObject:nativeController
+                                  forKey:nativeControllerKey];
+  return nativeController;
+}
+
+- (id)nativeControllerForTab:(Tab*)tab {
+  id nativeController = [_nativeControllersForTabIDs objectForKey:tab.tabId];
+  if (!nativeController) {
+    // If there is no controller, check for a native controller stored under
+    // the temporary key.
+    nativeController = [_nativeControllersForTabIDs
+        objectForKey:kNativeControllerTemporaryKey];
+  }
+  return nativeController;
+}
+
+#pragma mark - DialogPresenterDelegate methods
+
+- (void)dialogPresenter:(DialogPresenter*)presenter
+    willShowDialogForWebState:(web::WebState*)webState {
+  for (Tab* iteratedTab in self.tabModel) {
+    if ([iteratedTab webState] == webState) {
+      self.tabModel.currentTab = iteratedTab;
+      DCHECK([[iteratedTab view] isDescendantOfView:self.contentArea]);
+      break;
+    }
+  }
+}
+
+#pragma mark - Context menu methods
+
+- (void)searchByImageAtURL:(const GURL&)url
+                  referrer:(const web::Referrer)referrer {
+  DCHECK(url.is_valid());
+  base::WeakNSObject<BrowserViewController> weakSelf(self);
+  web::ImageFetchedCallback callback =
+      ^(const GURL& original_url, int response_code, NSData* data) {
+        GURL originalURL(original_url.spec());
+        DCHECK(data);
+        dispatch_async(dispatch_get_main_queue(), ^{
+          [weakSelf searchByImageData:data atURL:originalURL];
+        });
+      };
+  _imageFetcher->StartDownload(
+      url, callback, web::ReferrerHeaderValueForNavigation(url, referrer),
+      web::PolicyForNavigation(url, referrer));
+}
+
+- (void)searchByImageData:(NSData*)data atURL:(const GURL&)imageURL {
+  NSData* imageData = data;
+  UIImage* image = [UIImage imageWithData:imageData];
+  // Downsize the image if its area exceeds kSearchByImageMaxImageArea AND
+  // (either its width exceeds kSearchByImageMaxImageWidth OR its height exceeds
+  // kSearchByImageMaxImageHeight).
+  if (image &&
+      image.size.height * image.size.width > kSearchByImageMaxImageArea &&
+      (image.size.width > kSearchByImageMaxImageWidth ||
+       image.size.height > kSearchByImageMaxImageHeight)) {
+    CGSize newImageSize =
+        CGSizeMake(kSearchByImageMaxImageWidth, kSearchByImageMaxImageHeight);
+    image = [image gtm_imageByResizingToSize:newImageSize
+                         preserveAspectRatio:YES
+                                   trimToFit:NO];
+    imageData = UIImageJPEGRepresentation(image, 1.0);
+  }
+
+  char const* bytes = reinterpret_cast<const char*>([imageData bytes]);
+  std::string byteString(bytes, [imageData length]);
+
+  TemplateURLService* templateUrlService =
+      ios::TemplateURLServiceFactory::GetForBrowserState(_browserState);
+  TemplateURL* defaultURL = templateUrlService->GetDefaultSearchProvider();
+  DCHECK(!defaultURL->image_url().empty());
+  DCHECK(defaultURL->image_url_ref().IsValid(
+      templateUrlService->search_terms_data()));
+  TemplateURLRef::SearchTermsArgs search_args(base::ASCIIToUTF16(""));
+  search_args.image_url = imageURL;
+  search_args.image_thumbnail_content = byteString;
+
+  // Generate the URL and populate |post_content| with the content type and
+  // HTTP body for the request.
+  TemplateURLRef::PostContent post_content;
+  GURL result(defaultURL->image_url_ref().ReplaceSearchTerms(
+      search_args, templateUrlService->search_terms_data(), &post_content));
+  [self addSelectedTabWithURL:result
+                     postData:&post_content
+                   transition:ui::PAGE_TRANSITION_TYPED];
+}
+
+- (void)saveImageAtURL:(const GURL&)url
+              referrer:(const web::Referrer&)referrer {
+  DCHECK(url.is_valid());
+
+  NSString* fileName = [NSString
+      stringWithFormat:@"%@.png",
+                       [[NSProcessInfo processInfo] globallyUniqueString]];
+
+  if (url.SchemeIs(base::StringPiece("data"))) {
+    if (!base::StartsWith(url.GetContent(), "image",
+                          base::CompareCase::INSENSITIVE_ASCII)) {
+      // Not an image, return.
+      return;
+    }
+
+    // Find the type of the image. It should be positionned like here:
+    // "image/png;base...", between the '/' and the ';'.
+    size_t semiColonPosition = url.GetContent().find(std::string(";"));
+    size_t slashPosition = url.GetContent().find(std::string("/"));
+    size_t substrLength = semiColonPosition - slashPosition - 1;
+    if (substrLength > 1) {
+      // Make sure there is a type.
+      fileName = [NSString
+          stringWithFormat:@"image.%@",
+                           base::SysUTF8ToNSString(url.GetContent().substr(
+                               slashPosition + 1, substrLength))];
+    }
+  } else {
+    fileName = base::SysUTF8ToNSString(url.ExtractFileName());
+  }
+
+  web::ImageFetchedCallback callback =
+      ^(const GURL& original_url, int response_code, NSData* data) {
+        DCHECK(data);
+
+        [self managePermissionAndSaveImage:data fileName:fileName];
+      };
+  _imageFetcher->StartDownload(
+      url, callback, web::ReferrerHeaderValueForNavigation(url, referrer),
+      web::PolicyForNavigation(url, referrer));
+}
+
+- (void)managePermissionAndSaveImage:(NSData*)data
+                            fileName:(NSString*)fileName {
+  switch ([PHPhotoLibrary authorizationStatus]) {
+    // User was never asked for permission to access photos.
+    case PHAuthorizationStatusNotDetermined:
+      [PHPhotoLibrary requestAuthorization:^(PHAuthorizationStatus status) {
+        // Call -saveImage again to check if chrome needs to display an error or
+        // saves the image.
+        if (status != PHAuthorizationStatusNotDetermined)
+          [self managePermissionAndSaveImage:data fileName:fileName];
+      }];
+      break;
+
+    // The application doesn't have permission to access photo and the user
+    // cannot grant it.
+    case PHAuthorizationStatusRestricted:
+      [self displayPrivacyErrorAlertOnMainQueue:
+                l10n_util::GetNSString(
+                    IDS_IOS_SAVE_IMAGE_RESTRICTED_PRIVACY_ALERT_MESSAGE)];
+      break;
+
+    // The application doesn't have permission to access photo and the user
+    // can grant it.
+    case PHAuthorizationStatusDenied:
+      [self displayImageErrorAlertWithSettingsOnMainQueue];
+      break;
+
+    // The application has permission to access the photos.
+    default: {
+      web::WebThread::PostTask(web::WebThread::FILE, FROM_HERE,
+                               base::BindBlock(^{
+                                 [self saveImage:data fileName:fileName];
+                               }));
+      break;
+    }
+  }
+}
+
+- (void)saveImage:(NSData*)data fileName:(NSString*)fileName {
+  NSURL* fileURL =
+      [NSURL fileURLWithPath:[NSTemporaryDirectory()
+                                 stringByAppendingPathComponent:fileName]];
+  NSError* error = nil;
+  [data writeToURL:fileURL options:NSDataWritingAtomic error:&error];
+
+  // Error while writing the image to disk.
+  if (error) {
+    NSString* errorMessage = [NSString
+        stringWithFormat:@"%@ (%@ %" PRIdNS ")", [error localizedDescription],
+                         [error domain], [error code]];
+    [self displayPrivacyErrorAlertOnMainQueue:errorMessage];
+    return;
+  }
+
+  // Save the image to photos.
+  [[PHPhotoLibrary sharedPhotoLibrary] performChanges:^{
+    [PHAssetChangeRequest creationRequestForAssetFromImageAtFileURL:fileURL];
+  }
+      completionHandler:^(BOOL success, NSError* error) {
+        // Callback for the image saving.
+        [self finishSavingImageWithError:error];
+
+        // Cleanup the temporary file.
+        web::WebThread::PostTask(
+            web::WebThread::FILE, FROM_HERE, base::BindBlock(^{
+              NSError* error = nil;
+              [[NSFileManager defaultManager] removeItemAtURL:fileURL
+                                                        error:&error];
+            }));
+      }];
+}
+
+- (void)displayImageErrorAlertWithSettingsOnMainQueue {
+  NSURL* settingURL = [NSURL URLWithString:UIApplicationOpenSettingsURLString];
+  BOOL canGoToSetting =
+      [[UIApplication sharedApplication] canOpenURL:settingURL];
+  if (canGoToSetting) {
+    dispatch_async(dispatch_get_main_queue(), ^{
+      [self displayImageErrorAlertWithSettings:settingURL];
+    });
+  } else {
+    [self displayPrivacyErrorAlertOnMainQueue:
+              l10n_util::GetNSString(IDS_IOS_SAVE_IMAGE_PRIVACY_ALERT_MESSAGE)];
+  }
+}
+
+- (void)displayImageErrorAlertWithSettings:(NSURL*)settingURL {
+  // Dismiss current alert.
+  [_alertCoordinator stop];
+
+  NSString* title =
+      l10n_util::GetNSString(IDS_IOS_SAVE_IMAGE_PRIVACY_ALERT_TITLE);
+  NSString* message = l10n_util::GetNSString(
+      IDS_IOS_SAVE_IMAGE_PRIVACY_ALERT_MESSAGE_GO_TO_SETTINGS);
+
+  _alertCoordinator.reset([[AlertCoordinator alloc]
+      initWithBaseViewController:self
+                           title:title
+                         message:message]);
+
+  [_alertCoordinator addItemWithTitle:l10n_util::GetNSString(IDS_CANCEL)
+                               action:nil
+                                style:UIAlertActionStyleCancel];
+
+  [_alertCoordinator
+      addItemWithTitle:l10n_util::GetNSString(
+                           IDS_IOS_SAVE_IMAGE_PRIVACY_ALERT_GO_TO_SETTINGS)
+                action:^{
+                  OpenUrlWithCompletionHandler(settingURL, nil);
+                }
+                 style:UIAlertActionStyleDefault];
+
+  [_alertCoordinator start];
+}
+
+- (void)displayPrivacyErrorAlertOnMainQueue:(NSString*)errorContent {
+  dispatch_async(dispatch_get_main_queue(), ^{
+    NSString* title =
+        l10n_util::GetNSString(IDS_IOS_SAVE_IMAGE_PRIVACY_ALERT_TITLE);
+    [self showErrorAlertWithStringTitle:title message:errorContent];
+  });
+}
+
+// This callback is triggered when the image is effectively saved onto the photo
+// album, or if the save failed for some reason.
+- (void)finishSavingImageWithError:(NSError*)error {
+  // Was there an error?
+  if (error) {
+    // Saving photo failed even though user has granted access to Photos.
+    // Display the error information from the NSError object for user.
+    NSString* errorMessage = [NSString
+        stringWithFormat:@"%@ (%@ %" PRIdNS ")", [error localizedDescription],
+                         [error domain], [error code]];
+    // This code may be execute outside of the main thread. Make sure to display
+    // the error on the main thread.
+    [self displayPrivacyErrorAlertOnMainQueue:errorMessage];
+  } else {
+    // TODO(noyau): Ideally I'd like to show an infobar with a link to switch to
+    // the photo application. The current behaviour is to create the photo there
+    // but not providing any link to it is suboptimal. That's what Safari is
+    // doing, and what the PM want, but it doesn't make it right.
+  }
+}
+
+#pragma mark - BrowserIOS methods
+
+- (ios::ChromeBrowserState*)browserState {
+  return _browserState;
+}
+
+- (TabModel*)tabModel {
+  return _model.get();
+}
+
+#pragma mark - No-tabs UI methods
+
+// Show the No-Tabs UI (hiding normal tab/web ui).
+- (void)showNoTabsUI {
+  // The No-Tabs UI is only shown on tablet for non-incognito BVCs.  (Incognito
+  // mode does not have a No-Tabs UI; the user is simply shown the non-incognito
+  // BVC when the last incognito tab is closed.)
+  DCHECK(IsIPadIdiom());
+  DCHECK(!_isOffTheRecord);
+
+  // The method showNoTabsUI is called asynchronously when the number of tabs
+  // reaches zero. Do not show the no tabs UI if a tab was added in the mean
+  // time.
+  if ([_model count])
+    return;
+
+  DCHECK([_model currentTab] == nil);
+  DCHECK([_contentArea subviews].count == 0 ||
+         experimental_flags::IsTabSwitcherEnabled());
+  _noTabsController.reset([[NoTabsController alloc] initWithView:self.view]);
+
+  // Close the tools popup menu if it is open, as its contents/location were
+  // specific to being in the tabs UI.
+  [_toolbarController dismissToolsMenuPopup];
+
+  // Immediately hide the web, toolbar, and tabstrip.
+  [[_toolbarController view] setHidden:YES];
+  [[_tabStripController view] setHidden:YES];
+
+  // Set up the toggle switch animation, if needed.
+  if ([self hasModeToggleSwitch]) {
+    UIButton* animationStartButton = [_tabStripController modeToggleButton];
+    [_noTabsController installAnimationImageForButton:animationStartButton
+                                               inView:self.view
+                                                 show:YES];
+  }
+
+  [_noTabsController prepareForShowAnimation];
+  [UIView animateWithDuration:kNoTabsAnimationDuration
+      animations:^{
+        [_noTabsController showNoTabsUI];
+      }
+      completion:^(BOOL finished) {
+        [_noTabsController showAnimationDidFinish];
+        [_noTabsController setHasModeToggleSwitch:[self hasModeToggleSwitch]];
+      }];
+}
+
+// Hide the No-Tabs UI (restoring normal tab/web ui).
+- (void)dismissNoTabsUI {
+  // The No-Tabs UI is only shown on tablet for non-incognito BVCs, so there is
+  // no need to dismiss it for an incognito BVC.
+  DCHECK(IsIPadIdiom());
+  if (_isOffTheRecord)
+    return;
+
+  // Set up the toggle switch animation, if needed.
+  if ([self hasModeToggleSwitch]) {
+    UIButton* animationEndButton = [_tabStripController modeToggleButton];
+    [_noTabsController installAnimationImageForButton:animationEndButton
+                                               inView:self.view
+                                                 show:NO];
+  }
+
+  [_noTabsController prepareForDismissAnimation];
+
+  // Pull the controller out of the scoped_nsobject so the animation blocks can
+  // retain it.
+  NoTabsController* noTabsController = _noTabsController.get();
+  [UIView animateWithDuration:kNoTabsAnimationDuration
+      animations:^{
+        [noTabsController dismissNoTabsUI];
+      }
+      completion:^(BOOL finished) {
+        // When the animation is finished, remove all of the No-Tabs UI and
+        // reshow the tabstrip, web toolbar, and web.
+        [noTabsController dismissAnimationDidFinish];
+        [[_toolbarController view] setHidden:NO];
+        [[_tabStripController view] setHidden:NO];
+      }];
+  // Nullify the instance variable. The controller is retained by the animation.
+  // Nullifying this variable prevents button press performed during the
+  // animation to be routed to the noTabController.
+  _noTabsController.reset();
+}
+
+#pragma mark - Showing popups
+
+- (void)showToolsMenuPopup {
+  DCHECK(_browserState);
+  DCHECK(self.visible || self.dismissingModal);
+  DCHECK(!_noTabsController);
+
+  // Dismiss the omnibox (if open).
+  [_toolbarController cancelOmniboxEdit];
+  // Dismiss the soft keyboard (if open).
+  [[_model currentTab].webController dismissKeyboard];
+  // Dismiss Find in Page focus.
+  [self updateFindBar:NO shouldFocus:NO];
+
+  base::scoped_nsobject<ToolsMenuContext> context(
+      [[ToolsMenuContext alloc] initWithDisplayView:[self view]]);
+  if ([_model count] == 0)
+    [context setNoOpenedTabs:YES];
+  if (_isOffTheRecord)
+    [context setInIncognito:YES];
+  if (reading_list::switches::IsReadingListEnabled()) {
+    if (!_readingListMenuNotifier) {
+      _readingListMenuNotifier.reset([[ReadingListMenuNotifier alloc]
+          initWithReadingList:ReadingListModelFactory::GetForBrowserState(
+                                  _browserState)]);
+    }
+    [context setReadingListMenuNotifier:_readingListMenuNotifier];
+  }
+
+  [_toolbarController showToolsMenuPopupWithContext:context];
+  ToolsPopupController* toolsPopupController =
+      [_toolbarController toolsPopupController];
+  if ([_model currentTab]) {
+    BOOL isBookmarked = _toolbarModelIOS->IsCurrentTabBookmarked();
+    [toolsPopupController setIsCurrentPageBookmarked:isBookmarked];
+    [toolsPopupController setCanShowFindBar:self.canShowFindBar];
+    [toolsPopupController setCanUseReaderMode:self.canUseReaderMode];
+    [toolsPopupController
+        setCanUseDesktopUserAgent:self.canUseDesktopUserAgent];
+    [toolsPopupController setCanShowShareMenu:self.canShowShareMenu];
+
+    if (!IsIPadIdiom())
+      [toolsPopupController setIsTabLoading:_toolbarModelIOS->IsLoading()];
+  }
+}
+
+- (void)showPageInfoPopupForView:(UIView*)sourceView {
+  Tab* tab = [_model currentTab];
+  DCHECK([tab navigationManager]);
+  web::NavigationItem* navItem = [tab navigationManager]->GetVisibleItem();
+
+  // It is fully expected to have a navItem here, as showPageInfoPopup can only
+  // be trigerred by a button enabled when a current item matches some
+  // conditions. However a crash was seen were navItem was NULL hence this
+  // test after a DCHECK.
+  DCHECK(navItem);
+  if (!navItem)
+    return;
+
+  // Don't show if the page is native.
+  if ([self isTabNativePage:tab])
+    return;
+
+  base::RecordAction(UserMetricsAction("MobileToolbarPageSecurityInfo"));
+
+  // Dismiss the omnibox (if open).
+  [_toolbarController cancelOmniboxEdit];
+
+  [[NSNotificationCenter defaultCenter]
+      postNotificationName:ios_internal::kPageInfoWillShowNotification
+                    object:nil];
+
+  // TODO(rohitrao): Get rid of PageInfoModel completely.
+  PageInfoModelBubbleBridge* bridge = new PageInfoModelBubbleBridge();
+  PageInfoModel* pageInfoModel = new PageInfoModel(
+      _browserState, navItem->GetURL(), navItem->GetSSL(), bridge);
+
+  UIView* view = [self view];
+  _pageInfoController.reset([[PageInfoViewController alloc]
+      initWithModel:pageInfoModel
+             bridge:bridge
+        sourceFrame:[sourceView convertRect:[sourceView bounds] toView:view]
+         parentView:view]);
+  bridge->set_controller(_pageInfoController.get());
+}
+
+- (void)hidePageInfoPopupForView:(UIView*)sourceView {
+  [_pageInfoController dismiss];
+  _pageInfoController.reset();
+}
+
+- (void)showSecurityHelpPage {
+  [self webPageOrderedOpen:GURL(kPageInfoHelpCenterURL)
+                  referrer:web::Referrer()
+                windowName:nil
+              inBackground:NO
+                  appendTo:kCurrentTab];
+  [self hidePageInfoPopupForView:nil];
+}
+
+- (void)showTabHistoryPopupForBackwardHistory {
+  DCHECK(self.visible || self.dismissingModal);
+  DCHECK(!_noTabsController);
+
+  // Dismiss the omnibox (if open).
+  [_toolbarController cancelOmniboxEdit];
+  // Dismiss the soft keyboard (if open).
+  Tab* tab = [_model currentTab];
+  [tab.webController dismissKeyboard];
+
+  DCHECK([tab navigationManager]);
+  CRWSessionController* sc = [tab navigationManager]->GetSessionController();
+  [_toolbarController showTabHistoryPopupInView:[self view]
+                             withSessionEntries:[sc backwardEntries]
+                                 forBackHistory:YES];
+}
+
+- (void)showTabHistoryPopupForForwardHistory {
+  DCHECK(self.visible || self.dismissingModal);
+  DCHECK(!_noTabsController);
+
+  // Dismiss the omnibox (if open).
+  [_toolbarController cancelOmniboxEdit];
+  // Dismiss the soft keyboard (if open).
+  Tab* tab = [_model currentTab];
+  [tab.webController dismissKeyboard];
+
+  DCHECK([tab navigationManager]);
+  CRWSessionController* sc = [tab navigationManager]->GetSessionController();
+  [_toolbarController showTabHistoryPopupInView:[self view]
+                             withSessionEntries:[sc forwardEntries]
+                                 forBackHistory:NO];
+}
+
+- (void)navigateToSelectedEntry:(id)sender {
+  DCHECK([sender isKindOfClass:[TabHistoryCell class]]);
+  TabHistoryCell* selectedCell = (TabHistoryCell*)sender;
+  [[_model currentTab] goToEntry:selectedCell.entry];
+  [_toolbarController dismissTabHistoryPopup];
+}
+
+- (void)print {
+  Tab* currentTab = [_model currentTab];
+  // The UI should prevent users from printing non-printable pages. However, a
+  // redirection to an un-printable page can happen before it is reflected in
+  // the UI.
+  if (![currentTab viewForPrinting]) {
+    [self showSnackbar:l10n_util::GetNSString(IDS_IOS_CANNOT_PRINT_PAGE_ERROR)];
+    return;
+  }
+  DCHECK(_browserState);
+  if (!_printController.get()) {
+    _printController.reset([[PrintController alloc]
+        initWithContextGetter:_browserState->GetRequestContext()]);
+  }
+  [_printController printView:[currentTab viewForPrinting]
+                    withTitle:[currentTab title]
+               viewController:self];
+}
+
+- (void)addToReadingListURL:(const GURL&)URL title:(NSString*)title {
+  if (!reading_list::switches::IsReadingListEnabled()) {
+    return;
+  }
+  base::RecordAction(UserMetricsAction("MobileReadingListAdd"));
+
+  ReadingListModel* readingModel =
+      ReadingListModelFactory::GetForBrowserState(_browserState);
+  readingModel->AddEntry(URL, base::SysNSStringToUTF8(title));
+
+  NSString* snackBarMessage =
+      l10n_util::GetNSString(IDS_IOS_READING_LIST_SNACKBAR_MESSAGE);
+  MDCSnackbarMessage* message =
+      [MDCSnackbarMessage messageWithText:snackBarMessage];
+  message.category = kReadingListSnackbarCategory;
+  [MDCSnackbarManager showMessage:message];
+}
+
+#pragma mark - Keyboard commands management
+
+- (BOOL)shouldRegisterKeyboardCommands {
+  if ([self presentedViewController])
+    return NO;
+
+  if (_voiceSearchController && _voiceSearchController->IsVisible())
+    return NO;
+
+  // If there is no first responder, try to make the webview the first
+  // responder.
+  if (!GetFirstResponder()) {
+    [_model.get().currentTab.webController.webViewProxy becomeFirstResponder];
+  }
+
+  return YES;
+}
+
+- (KeyCommandsProvider*)keyCommandsProvider {
+  if (!_keyCommandsProvider) {
+    _keyCommandsProvider.reset([_dependencyFactory newKeyCommandsProvider]);
+  }
+  return _keyCommandsProvider.get();
+}
+
+#pragma mark - KeyCommandsPlumbing
+
+- (BOOL)isOffTheRecord {
+  return _isOffTheRecord;
+}
+
+- (NSUInteger)tabsCount {
+  return [_model count];
+}
+
+- (void)focusTabAtIndex:(NSUInteger)index {
+  if ([_model count] > index) {
+    [_model setCurrentTab:[_model tabAtIndex:index]];
+  }
+}
+
+- (void)focusNextTab {
+  NSInteger currentTabIndex = [_model indexOfTab:[_model currentTab]];
+  NSInteger modelCount = [_model count];
+  if (currentTabIndex < modelCount - 1) {
+    Tab* nextTab = [_model tabAtIndex:currentTabIndex + 1];
+    [_model setCurrentTab:nextTab];
+  } else {
+    [_model setCurrentTab:[_model tabAtIndex:0]];
+  }
+}
+
+- (void)focusPreviousTab {
+  NSInteger currentTabIndex = [_model indexOfTab:[_model currentTab]];
+  if (currentTabIndex > 0) {
+    Tab* previousTab = [_model tabAtIndex:currentTabIndex - 1];
+    [_model setCurrentTab:previousTab];
+  } else {
+    Tab* lastTab = [_model tabAtIndex:[_model count] - 1];
+    [_model setCurrentTab:lastTab];
+  }
+}
+
+- (void)reopenClosedTab {
+  sessions::TabRestoreService* const tabRestoreService =
+      IOSChromeTabRestoreServiceFactory::GetForBrowserState(_browserState);
+  if (!tabRestoreService || tabRestoreService->entries().empty())
+    return;
+
+  const std::unique_ptr<sessions::TabRestoreService::Entry>& entry =
+      tabRestoreService->entries().front();
+  // Only handle the TAB type.
+  if (entry->type != sessions::TabRestoreService::TAB)
+    return;
+
+  [self chromeExecuteCommand:[GenericChromeCommand commandWithTag:IDC_NEW_TAB]];
+  TabRestoreServiceDelegateImplIOS* const delegate =
+      TabRestoreServiceDelegateImplIOSFactory::GetForBrowserState(
+          _browserState);
+  tabRestoreService->RestoreEntryById(delegate, entry->id,
+                                      WindowOpenDisposition::CURRENT_TAB);
+}
+
+- (void)focusOmnibox {
+  [_toolbarController focusOmnibox];
+}
+
+#pragma mark - UIResponder
+
+- (NSArray*)keyCommands {
+  if (![self shouldRegisterKeyboardCommands]) {
+    return nil;
+  }
+  return [self.keyCommandsProvider
+      keyCommandsForConsumer:self
+                 editingText:![self isFirstResponder]];
+}
+
+#pragma mark -
+
+// Induce an intentional crash in the browser process.
+- (void)induceBrowserCrash {
+  CHECK(false);
+  // Call another function, so that the above CHECK can't be tail-call
+  // optimized. This ensures that this method's name will show up in the stack
+  // for easier identification.
+  CHECK(true);
+}
+
+- (void)loadURL:(const GURL&)url
+             referrer:(const web::Referrer&)referrer
+           transition:(ui::PageTransition)transition
+    rendererInitiated:(BOOL)rendererInitiated {
+  [[OmniboxGeolocationController sharedInstance]
+      locationBarDidSubmitURL:url
+                   transition:transition
+                 browserState:_browserState];
+
+  [_bookmarkInteractionController dismissBookmarkModalControllerAnimated:YES];
+  if (transition & ui::PAGE_TRANSITION_FROM_ADDRESS_BAR) {
+    new_tab_page_uma::RecordActionFromOmnibox(_browserState, url, transition);
+  }
+
+  // NOTE: This check for the Crash Host URL is here to avoid the URL from
+  // ending up in the history causign the app to crash at every subsequent
+  // restart.
+  if (url.host() == kChromeUIBrowserCrashHost) {
+    [self induceBrowserCrash];
+    // In debug the app can continue working even after the CHECK. Adding a
+    // return avoids the crash url to be added to the history.
+    return;
+  }
+
+  if (url == [_preloadController prerenderedURL]) {
+    Tab* oldTab = [_model currentTab];
+    Tab* newTab = [_preloadController releasePrerenderContents];
+    DCHECK(oldTab);
+    DCHECK(newTab);
+    if (oldTab && newTab) {
+      [oldTab recordStateInHistory];
+      DCHECK([newTab navigationManager]);
+      CRWSessionController* newHistory =
+          [newTab navigationManager]->GetSessionController();
+      DCHECK([oldTab navigationManager]);
+      CRWSessionController* oldHistory =
+          [oldTab navigationManager]->GetSessionController();
+      [newHistory insertStateFromSessionController:oldHistory];
+      [[newTab nativeAppNavigationController]
+          copyStateFrom:[oldTab nativeAppNavigationController]];
+      [_model replaceTab:oldTab withTab:newTab keepOldTabOpen:NO];
+
+      // Set isPrerenderTab to NO after replacing the tab. This will allow the
+      // BrowserViewController to detect that a pre-rendered tab is switched in,
+      // and show the prerendering animation.
+      newTab.isPrerenderTab = NO;
+
+      BOOL loadingFinished =
+          [newTab.webController loadPhase] == web::PAGE_LOADED;
+      [self tabLoadComplete:newTab withSuccess:loadingFinished];
+
+      return;
+    }
+  }
+
+  GURL urlToLoad = url;
+  if ([_preloadController hasPrefetchedURL:url]) {
+    // Prefetched URLs have modified URLs, so load the prefetched version of
+    // |url| instead of the original |url|.
+    urlToLoad = [_preloadController prefetchedURL];
+  }
+
+  [_preloadController cancelPrerender];
+
+  // Some URLs are not allowed while in incognito.  If we are in incognito and
+  // load a disallowed URL, instead create a new tab not in the incognito state.
+  if (_isOffTheRecord && !IsURLAllowedInIncognito(url)) {
+    [self webPageOrderedOpen:url
+                    referrer:web::Referrer()
+                  windowName:nil
+                 inIncognito:NO
+                inBackground:NO
+                    appendTo:kCurrentTab];
+    return;
+  }
+
+  web::NavigationManager::WebLoadParams params(urlToLoad);
+  params.referrer = referrer;
+  params.transition_type = transition;
+  params.is_renderer_initiated = rendererInitiated;
+  DCHECK([_model currentTab]);
+  [[[_model currentTab] webController] loadWithParams:params];
+}
+
+- (void)loadJavaScriptFromLocationBar:(NSString*)script {
+  [_preloadController cancelPrerender];
+  DCHECK([_model currentTab]);
+  [[_model currentTab].webController executeUserJavaScript:script
+                                         completionHandler:nil];
+}
+
+- (web::WebState*)currentWebState {
+  return [[_model currentTab] webState];
+}
+
+// This is called from within an animation block.
+- (void)toolbarHeightChanged {
+  if ([self headerHeight] != 0) {
+    // Ensure full screen height is updated.
+    Tab* currentTab = [_model currentTab];
+    BOOL visible = self.isToolbarOnScreen;
+    [currentTab updateFullscreenWithToolbarVisible:visible];
+  }
+}
+
+// Load a new URL on a new page/tab.
+- (void)webPageOrderedOpen:(const GURL&)URL
+                  referrer:(const web::Referrer&)referrer
+                windowName:(NSString*)windowName
+              inBackground:(BOOL)inBackground
+                  appendTo:(OpenPosition)appendTo {
+  Tab* adjacentTab = nil;
+  if (appendTo == kCurrentTab)
+    adjacentTab = [_model currentTab];
+  [_model insertOrUpdateTabWithURL:URL
+                          referrer:referrer
+                        transition:ui::PAGE_TRANSITION_LINK
+                        windowName:windowName
+                            opener:adjacentTab
+                       openedByDOM:NO
+                           atIndex:TabModelConstants::kTabPositionAutomatically
+                      inBackground:inBackground];
+}
+
+- (void)webPageOrderedOpen:(const GURL&)url
+                  referrer:(const web::Referrer&)referrer
+                windowName:(NSString*)windowName
+               inIncognito:(BOOL)inIncognito
+              inBackground:(BOOL)inBackground
+                  appendTo:(OpenPosition)appendTo {
+  if (inIncognito == _isOffTheRecord) {
+    [self webPageOrderedOpen:url
+                    referrer:referrer
+                  windowName:windowName
+                inBackground:inBackground
+                    appendTo:appendTo];
+    return;
+  }
+  // When sending an open command that switches modes, ensure the tab
+  // ends up appended to the end of the model, not just next to what is
+  // currently selected in the other mode. This is done with the |append|
+  // parameter.
+  base::scoped_nsobject<OpenUrlCommand> command([[OpenUrlCommand alloc]
+       initWithURL:url
+          referrer:web::Referrer()  // Strip referrer when switching modes.
+        windowName:windowName
+       inIncognito:inIncognito
+      inBackground:inBackground
+          appendTo:kLastTab]);
+  [self chromeExecuteCommand:command];
+}
+
+- (void)loadSessionTab:(const sessions::SessionTab*)sessionTab {
+  [[_model currentTab] loadSessionTab:sessionTab];
+}
+
+- (void)openJavascript:(NSString*)javascript {
+  [[_model currentTab] openJavascript:javascript];
+}
+
+#pragma mark - WebToolbarDelegate methods
+
+- (IBAction)locationBarDidBecomeFirstResponder:(id)sender {
+  if (_locationBarHasFocus)
+    return;  // TODO(crbug.com/244366): This should not be necessary.
+  _locationBarHasFocus = YES;
+  [[NSNotificationCenter defaultCenter]
+      postNotificationName:ios_internal::
+                               kLocationBarBecomesFirstResponderNotification
+                    object:nil];
+  [_sideSwipeController setEnabled:NO];
+  if ([[_model currentTab].webController wantsKeyboardShield]) {
+    [[self view] insertSubview:_typingShield aboveSubview:_contentArea];
+    [_typingShield setAlpha:0.0];
+    [_typingShield setHidden:NO];
+    [UIView animateWithDuration:0.3
+                     animations:^{
+                       [_typingShield setAlpha:1.0];
+                     }];
+  }
+  [[OmniboxGeolocationController sharedInstance]
+      locationBarDidBecomeFirstResponder:_browserState];
+}
+
+- (IBAction)locationBarDidResignFirstResponder:(id)sender {
+  if (!_locationBarHasFocus)
+    return;  // TODO(crbug.com/244366): This should not be necessary.
+  _locationBarHasFocus = NO;
+  [_sideSwipeController setEnabled:YES];
+  [[NSNotificationCenter defaultCenter]
+      postNotificationName:ios_internal::
+                               kLocationBarResignsFirstResponderNotification
+                    object:nil];
+  [UIView animateWithDuration:0.3
+      animations:^{
+        [_typingShield setAlpha:0.0];
+      }
+      completion:^(BOOL finished) {
+        // This can happen if one quickly resigns the omnibox and then taps
+        // on the omnibox again during this animation. If the animation is
+        // interrupted and the toolbar controller is first responder, it's safe
+        // to assume the |_typingShield| shouldn't be hidden here.
+        if (!finished && [_toolbarController isOmniboxFirstResponder])
+          return;
+        [_typingShield setHidden:YES];
+      }];
+  [[OmniboxGeolocationController sharedInstance]
+      locationBarDidResignFirstResponder:_browserState];
+
+  // If a load was cancelled by an omnibox edit, but nothing is loading when
+  // editing ends (i.e., editing was cancelled), restart the cancelled load.
+  if (_locationBarEditCancelledLoad) {
+    _locationBarEditCancelledLoad = NO;
+    if (!_toolbarModelIOS->IsLoading()) {
+      [[_model currentTab] reload];
+    }
+  }
+}
+
+- (IBAction)locationBarBeganEdit:(id)sender {
+  // On handsets, if a page is currently loading it should be stopped.
+  if (!IsIPadIdiom() && _toolbarModelIOS->IsLoading()) {
+    base::scoped_nsobject<GenericChromeCommand> command(
+        [[GenericChromeCommand alloc] initWithTag:IDC_STOP]);
+    [self chromeExecuteCommand:command];
+    _locationBarEditCancelledLoad = YES;
+  }
+}
+
+- (IBAction)prepareToEnterTabSwitcher:(id)sender {
+  [[_model currentTab] updateSnapshotWithOverlay:YES visibleFrameOnly:YES];
+}
+
+- (ToolbarModelIOS*)toolbarModelIOS {
+  return _toolbarModelIOS.get();
+}
+
+- (void)updateToolbarBackgroundAlpha:(CGFloat)alpha {
+  [_toolbarController setBackgroundAlpha:alpha];
+}
+
+- (void)updateToolbarControlsAlpha:(CGFloat)alpha {
+  [_toolbarController setControlsAlpha:alpha];
+}
+
+- (void)willUpdateToolbarSnapshot {
+  [[_model currentTab].overscrollActionsController clear];
+}
+
+- (CardView*)addCardViewInFullscreen:(BOOL)fullScreen {
+  CGRect frame = [_contentArea frame];
+  if (!fullScreen) {
+    // Changing the origin here is unnecessary, it's set in page_animation_util.
+    frame.size.height -= [self headerHeight];
+  }
+
+  CGFloat shortAxis = frame.size.width;
+  CGFloat shortInset = kCardImageInsets.left + kCardImageInsets.right;
+  shortAxis -= shortInset + 2 * ios_internal::page_animation_util::kCardMargin;
+  CGFloat aspectRatio = frame.size.height / frame.size.width;
+  CGFloat longAxis = std::floor(aspectRatio * shortAxis);
+  CGFloat longInset = kCardImageInsets.top + kCardImageInsets.bottom;
+  CGSize cardSize = CGSizeMake(shortAxis + shortInset, longAxis + longInset);
+  CGRect cardFrame = {frame.origin, cardSize};
+
+  CardView* card =
+      [[[CardView alloc] initWithFrame:cardFrame isIncognito:_isOffTheRecord]
+          autorelease];
+  card.closeButtonSide = IsPortrait() ? CardCloseButtonSide::TRAILING
+                                      : CardCloseButtonSide::LEADING;
+  [_contentArea addSubview:card];
+  return card;
+}
+
+#pragma mark - Command Handling
+
+- (IBAction)chromeExecuteCommand:(id)sender {
+  NSInteger command = [sender tag];
+
+  if (!_model || !_browserState)
+    return;
+
+  switch (command) {
+    case IDC_BACK:
+      [[_model currentTab] goBack];
+      break;
+    case IDC_BOOKMARK_PAGE:
+      [self initializeBookmarkInteractionController];
+      [_bookmarkInteractionController
+          presentBookmarkForTab:[_model currentTab]
+            currentlyBookmarked:_toolbarModelIOS->IsCurrentTabBookmarkedByUser()
+                         inView:[_toolbarController bookmarkButtonView]
+                     originRect:[_toolbarController bookmarkButtonAnchorRect]];
+      break;
+    case IDC_CLOSE_TAB:
+      [self closeCurrentTab];
+      break;
+    case IDC_FIND:
+      [self initFindBarForTab];
+      break;
+    case IDC_FIND_NEXT:
+      // TODO(crbug.com/603524): Reshow find bar if necessary.
+      [[_model currentTab].findInPageController
+          findNextStringInPageWithCompletionHandler:^{
+            FindInPageModel* model =
+                [_model currentTab].findInPageController.findInPageModel;
+            [_findBarController updateResultsCount:model];
+          }];
+      break;
+    case IDC_FIND_PREVIOUS:
+      // TODO(crbug.com/603524): Reshow find bar if necessary.
+      [[_model currentTab].findInPageController
+          findPreviousStringInPageWithCompletionHandler:^{
+            FindInPageModel* model =
+                [_model currentTab].findInPageController.findInPageModel;
+            [_findBarController updateResultsCount:model];
+          }];
+      break;
+    case IDC_FIND_CLOSE:
+      [self closeFindInPage];
+      break;
+    case IDC_FIND_UPDATE:
+      [self searchFindInPage];
+      break;
+    case IDC_FORWARD:
+      [[_model currentTab] goForward];
+      break;
+    case IDC_FULLSCREEN:
+      NOTIMPLEMENTED();
+      break;
+    case IDC_HELP_PAGE_VIA_MENU:
+      [self showHelpPage];
+      break;
+    case IDC_NEW_TAB:
+      if (_isOffTheRecord) {
+        // Not for this browser state, send it on its way.
+        [super chromeExecuteCommand:sender];
+      } else {
+        [self newTab:sender];
+      }
+      break;
+    case IDC_PRELOAD_VOICE_SEARCH:
+      // Preload VoiceSearchController and views and view controllers needed
+      // for voice search.
+      [self ensureVoiceSearchControllerCreated];
+      _voiceSearchController->PrepareToAppear();
+      break;
+    case IDC_NEW_INCOGNITO_TAB:
+      if (_isOffTheRecord) {
+        [self newTab:sender];
+      } else {
+        // Not for this browser state, send it on its way.
+        [super chromeExecuteCommand:sender];
+      }
+      break;
+    case IDC_RELOAD:
+      [[_model currentTab] reload];
+      break;
+    case IDC_SHARE_PAGE:
+      [self sharePage];
+      break;
+    case IDC_SHOW_MAIL_COMPOSER:
+      [self showMailComposer:sender];
+      break;
+    case IDC_READER_MODE:
+      [[_model currentTab] switchToReaderMode];
+      break;
+    case IDC_REQUEST_DESKTOP_SITE:
+      [self enableDesktopUserAgent];
+      break;
+    case IDC_SHOW_TOOLS_MENU: {
+      // TODO(blundell): Change this if/else to
+      // |DCHECK(!_noTabsController)| if/when the no tabs controller
+      // becomes part of the responder chain.
+      // The no tabs controller's toolbar should open the menu when in the
+      // no-tabs UI.
+      if (_noTabsController.get())
+        [_noTabsController showToolsMenuPopup];
+      else
+        [self showToolsMenuPopup];
+      break;
+    }
+    case IDC_SHOW_BOOKMARK_MANAGER: {
+      if (IsIPadIdiom()) {
+        [self showAllBookmarks];
+      } else {
+        [self initializeBookmarkInteractionController];
+        [_bookmarkInteractionController presentBookmarks];
+      }
+      break;
+    }
+    case IDC_SHOW_OTHER_DEVICES: {
+      if (IsIPadIdiom()) {
+        [self showNTPPanel:NewTabPage::kOpenTabsPanel];
+      } else {
+        UIViewController* controller = [RecentTabsPanelViewController
+            controllerToPresentForBrowserState:_browserState
+                                        loader:self];
+        controller.modalPresentationStyle = UIModalPresentationFormSheet;
+        controller.modalPresentationCapturesStatusBarAppearance = YES;
+        [self presentViewController:controller animated:YES completion:nil];
+      }
+      break;
+    }
+    case IDC_STOP:
+      [[_model currentTab] stopLoading];
+      break;
+#if !defined(NDEBUG)
+    case IDC_VIEW_SOURCE:
+      [self viewSource];
+      break;
+#endif
+    case IDC_SHOW_PAGE_INFO:
+      DCHECK([sender isKindOfClass:[UIButton class]]);
+      [self showPageInfoPopupForView:sender];
+      break;
+    case IDC_HIDE_PAGE_INFO:
+      [[NSNotificationCenter defaultCenter]
+          postNotificationName:ios_internal::kPageInfoWillHideNotification
+                        object:nil];
+      [self hidePageInfoPopupForView:sender];
+      break;
+    case IDC_SHOW_SECURITY_HELP:
+      [self showSecurityHelpPage];
+      break;
+    case IDC_SHOW_BACK_HISTORY:
+      [self showTabHistoryPopupForBackwardHistory];
+      break;
+    case IDC_SHOW_FORWARD_HISTORY:
+      [self showTabHistoryPopupForForwardHistory];
+      break;
+    case IDC_BACK_FORWARD_IN_TAB_HISTORY:
+      DCHECK([sender isKindOfClass:[TabHistoryCell class]]);
+      [self navigateToSelectedEntry:sender];
+      break;
+    case IDC_PRINT:
+      [self print];
+      break;
+    case IDC_ADD_READING_LIST: {
+      DCHECK(reading_list::switches::IsReadingListEnabled());
+      ReadingListAddCommand* command =
+          base::mac::ObjCCastStrict<ReadingListAddCommand>(sender);
+      [self addToReadingListURL:[command URL] title:[command title]];
+      break;
+    }
+    case IDC_RATE_THIS_APP:
+      [self showRateThisAppDialog];
+      break;
+    case IDC_SHOW_READING_LIST:
+      DCHECK(reading_list::switches::IsReadingListEnabled());
+      [self showReadingList];
+      break;
+    case IDC_VOICE_SEARCH:
+      // If the voice search command is coming from a UIView sender, store it
+      // before sending the command up the responder chain.
+      if ([sender isKindOfClass:[UIView class]])
+        _voiceSearchButton.reset(sender);
+      [super chromeExecuteCommand:sender];
+      break;
+    case IDC_SHOW_QR_SCANNER:
+      if (experimental_flags::IsQRCodeReaderEnabled()) {
+        [self showQRScanner];
+      }
+      break;
+    default:
+      // Unknown commands get sent up the responder chain.
+      [super chromeExecuteCommand:sender];
+      break;
+  }
+}
+
+- (void)closeCurrentTab {
+  Tab* currentTab = [_model currentTab];
+  NSUInteger tabIndex = [_model indexOfTab:currentTab];
+  if (tabIndex == NSNotFound)
+    return;
+
+  // Take snapshot on iPad only if Tab switcher is enabled, if not just close
+  // the tab.
+  if (IsIPadIdiom() && !experimental_flags::IsTabSwitcherEnabled()) {
+    [_model closeTabAtIndex:tabIndex];
+    return;
+  }
+
+  // Create image of tab for close animation.
+  UIImageView* exitingPage = [self pageOpenCloseAnimationView];
+  exitingPage.image =
+      [currentTab updateSnapshotWithOverlay:YES visibleFrameOnly:YES];
+
+  // Close the actual tab, and add its image as a subview.
+  [_model closeTabAtIndex:tabIndex];
+
+  // Do not animate close in iPad.
+  if (!IsIPadIdiom()) {
+    [_contentArea addSubview:exitingPage];
+    ios_internal::page_animation_util::AnimateOutWithCompletion(
+        exitingPage, 0, YES, IsPortrait(), ^{
+          [exitingPage removeFromSuperview];
+        });
+  }
+}
+
+- (ShareToData*)shareToDataForTab:(Tab*)tab {
+  // For crash documented in crbug.com/503955, tab.url which is being passed
+  // as a reference parameter caused a crash due to invalid address which
+  // which suggests that |tab| may be deallocated along the way. Check that
+  // tab is still valid by checking webState which would be deallocated if
+  // tab is being closed.
+  if (!tab.webState)
+    return nil;
+  DCHECK(tab);
+  // If the original page title exists, it is expected to match the tab title.
+  // If this ever changes, then a decision has to be made on which one should
+  // be used for sharing.
+  DCHECK(!tab.originalTitle || [tab.originalTitle isEqualToString:tab.title]);
+  BOOL isPagePrintable = [tab viewForPrinting] != nil;
+  return [[[ShareToData alloc] initWithURL:tab.url
+                                     title:tab.title
+                           isOriginalTitle:(tab.originalTitle != nil)
+                           isPagePrintable:isPagePrintable] autorelease];
+}
+
+- (void)sharePage {
+  ShareToData* data = [self shareToDataForTab:[_model currentTab]];
+  if (data)
+    [self sharePageWithData:data];
+}
+
+- (void)sharePageWithData:(ShareToData*)data {
+  id<ShareProtocol> controller = [_dependencyFactory shareControllerInstance];
+  if ([controller isActive])
+    return;
+  CGRect fromRect = [_toolbarController shareButtonAnchorRect];
+  UIView* inView = [_toolbarController shareButtonView];
+  [controller shareWithData:data
+                 controller:self
+               browserState:_browserState
+            shareToDelegate:self
+                   fromRect:fromRect
+                     inView:inView];
+}
+
+- (void)clearPresentedStateWithCompletion:(ProceduralBlock)completion {
+  [[_dependencyFactory shareControllerInstance] cancelShareAnimated:NO];
+  [_bookmarkInteractionController dismissBookmarkModalControllerAnimated:NO];
+  [_bookmarkInteractionController dismissSnackbar];
+  [_toolbarController cancelOmniboxEdit];
+  [_dialogPresenter cancelAllDialogs];
+  [self hidePageInfoPopupForView:nil];
+  if (_voiceSearchController)
+    _voiceSearchController->DismissMicPermissionsHelp();
+  [[_model currentTab] dismissModals];
+  [[_model currentTab].findInPageController
+      disableFindInPageWithCompletionHandler:^{
+        [self updateFindBar:NO shouldFocus:NO];
+      }];
+  [_contextualSearchController movePanelOffscreen];
+
+  [_paymentRequestManager cancelRequest];
+
+  [_printController dismissAnimated:YES];
+  _printController.reset();
+  if (_noTabsController.get())
+    [_noTabsController dismissToolsMenuPopup];
+  else
+    [_toolbarController dismissToolsMenuPopup];
+  [_contextMenuCoordinator stop];
+  [self dismissRateThisAppDialog];
+
+  if (self.presentedViewController) {
+    // Dismisses any other modal controllers that may be present, e.g. Recent
+    // Tabs.
+    // Note that currently, some controllers like the bookmark ones were already
+    // dismissed (in this example in -dismissBookmarkModalControllerAnimated:),
+    // but are still reported as the presentedViewController. The result is that
+    // this will call -dismissViewControllerAnimated:completion: a second time
+    // on it. It is not per se an issue, as it is a no-op. The problem is that
+    // in such a case, the completion block is not called.
+    // To ensure the completion is called, nil is passed here, and the
+    // completion is called below.
+    [self dismissViewControllerAnimated:NO completion:nil];
+    // Dismissed controllers will be so after a delay. Queue the completion
+    // callback after that.
+    if (completion) {
+      dispatch_after(
+          dispatch_time(DISPATCH_TIME_NOW, (int64_t)(0.4 * NSEC_PER_SEC)),
+          dispatch_get_main_queue(), ^{
+            completion();
+          });
+    }
+  } else if (completion) {
+    // If no view controllers are presented, we should be ok with dispatching
+    // the completion block directly.
+    dispatch_async(dispatch_get_main_queue(), completion);
+  }
+}
+
+- (void)showHelpPage {
+  GURL helpUrl(l10n_util::GetStringUTF16(IDS_IOS_TOOLS_MENU_HELP_URL));
+  [self webPageOrderedOpen:helpUrl
+                  referrer:web::Referrer()
+                windowName:nil
+              inBackground:NO
+                  appendTo:kCurrentTab];
+}
+
+- (void)enableDesktopUserAgent {
+  [[_model currentTab] enableDesktopUserAgent];
+  [[_model currentTab] reloadForDesktopUserAgent];
+}
+
+- (void)resetAllWebViews {
+  [_model resetAllWebViews];
+}
+
+#pragma mark - Find Bar
+
+- (void)hideFindBarWithAnimation:(BOOL)animate {
+  [_findBarController hideFindBarView:animate];
+}
+
+- (void)showFindBarWithAnimation:(BOOL)animate
+                      selectText:(BOOL)selectText
+                     shouldFocus:(BOOL)shouldFocus {
+  DCHECK(_findBarController);
+  Tab* tab = [_model currentTab];
+  DCHECK(tab);
+  CRWWebController* webController = tab.webController;
+
+  CGRect referenceFrame = CGRectZero;
+  if (IsIPadIdiom()) {
+    referenceFrame = webController.visibleFrame;
+    referenceFrame.origin.y -= kIPadFindBarOverlap;
+  } else {
+    referenceFrame = _contentArea.frame;
+  }
+
+  CGRect omniboxFrame = [_toolbarController visibleOmniboxFrame];
+  [_findBarController addFindBarView:animate
+                            intoView:self.view
+                           withFrame:referenceFrame
+                      alignWithFrame:omniboxFrame
+                          selectText:selectText];
+  [self updateFindBar:YES shouldFocus:shouldFocus];
+}
+
+// Create find bar controller and pass it to the web controller.
+- (void)initFindBarForTab {
+  if (!self.canShowFindBar)
+    return;
+
+  if (!_findBarController)
+    _findBarController.reset(
+        [[FindBarControllerIOS alloc] initWithIncognito:_isOffTheRecord]);
+
+  Tab* tab = [_model currentTab];
+  DCHECK(!tab.findInPageController.findInPageModel.enabled);
+  tab.findInPageController.findInPageModel.enabled = YES;
+  [self showFindBarWithAnimation:YES selectText:YES shouldFocus:YES];
+}
+
+- (void)searchFindInPage {
+  FindInPageController* findInPageController =
+      [[_model currentTab] findInPageController];
+  base::WeakNSObject<BrowserViewController> weakSelf(self);
+  [findInPageController
+       findStringInPage:[_findBarController searchTerm]
+      completionHandler:^{
+        FindInPageModel* model =
+            [_model currentTab].findInPageController.findInPageModel;
+        [_findBarController updateResultsCount:model];
+      }];
+  if (!_isOffTheRecord)
+    [findInPageController saveSearchTerm];
+}
+
+- (void)closeFindInPage {
+  base::WeakNSObject<BrowserViewController> weakSelf(self);
+  [[_model currentTab].findInPageController
+      disableFindInPageWithCompletionHandler:^{
+        [weakSelf updateFindBar:NO shouldFocus:NO];
+      }];
+}
+
+- (void)updateFindBar:(BOOL)initialUpdate shouldFocus:(BOOL)shouldFocus {
+  FindInPageModel* model =
+      [_model currentTab].findInPageController.findInPageModel;
+  if (model.enabled) {
+    if (initialUpdate && !_isOffTheRecord) {
+      [[_model currentTab].findInPageController restoreSearchTerm];
+    }
+
+    [self setFramesForHeaders:[self headerViews]
+                     atOffset:[self currentHeaderOffset]];
+    [_findBarController updateView:model
+                     initialUpdate:initialUpdate
+                    focusTextfield:shouldFocus];
+  } else {
+    [self hideFindBarWithAnimation:YES];
+  }
+}
+
+- (void)showAllBookmarks {
+  DCHECK(self.visible || self.dismissingModal);
+  GURL URL(kChromeUIBookmarksURL);
+  Tab* tab = [_model currentTab];
+  web::NavigationManager::WebLoadParams params(URL);
+  params.transition_type = ui::PAGE_TRANSITION_AUTO_BOOKMARK;
+  [[tab webController] loadWithParams:params];
+}
+
+- (void)showReadingList {
+  DCHECK(reading_list::switches::IsReadingListEnabled());
+  UIViewController* vc = [ReadingListViewControllerBuilder
+      readingListViewControllerInBrowserState:self.browserState
+                                     tabModel:_model];
+  [self presentViewController:vc animated:YES completion:nil];
+}
+
+- (void)showQRScanner {
+  _qrScannerViewController.reset(
+      [[QRScannerViewController alloc] initWithDelegate:_toolbarController]);
+  [self presentViewController:[_qrScannerViewController
+                                  getViewControllerToPresent]
+                     animated:YES
+                   completion:nil];
+}
+
+- (void)showNTPPanel:(NewTabPage::PanelIdentifier)panel {
+  DCHECK(self.visible || self.dismissingModal);
+  GURL url(kChromeUINewTabURL);
+  std::string fragment(NewTabPage::FragmentFromIdentifier(panel));
+  if (fragment != "") {
+    GURL::Replacements replacement;
+    replacement.SetRefStr(fragment);
+    url = url.ReplaceComponents(replacement);
+  }
+  Tab* tab = [_model currentTab];
+  web::NavigationManager::WebLoadParams params(url);
+  params.transition_type = ui::PAGE_TRANSITION_AUTO_BOOKMARK;
+  [[tab webController] loadWithParams:params];
+}
+
+- (void)showRateThisAppDialog {
+  DCHECK(!_rateThisAppDialog.get());
+
+  // Store the current timestamp whenever this dialog is shown.
+  _browserState->GetPrefs()->SetInt64(prefs::kRateThisAppDialogLastShownTime,
+                                      base::Time::Now().ToInternalValue());
+
+  // Some versions of iOS7 do not support linking directly to the "Ratings and
+  // Reviews" appstore page.  For iOS7 fall back to an alternative URL that
+  // links to the main appstore page for the Chrome app.
+  NSURL* storeURL =
+      [NSURL URLWithString:(@"itms-apps://itunes.apple.com/WebObjects/"
+                            @"MZStore.woa/wa/"
+                            @"viewContentsUserReviews?type=Purple+Software&id="
+                            @"535886823&pt=9008&ct=rating")];
+
+  base::RecordAction(base::UserMetricsAction("IOSRateThisAppDialogShown"));
+  [self clearPresentedStateWithCompletion:nil];
+
+  _rateThisAppDialog.reset(
+      ios::GetChromeBrowserProvider()->CreateAppRatingPrompt());
+  [_rateThisAppDialog setAppStoreURL:storeURL];
+  [_rateThisAppDialog setDelegate:self];
+  [_rateThisAppDialog show];
+}
+
+- (void)dismissRateThisAppDialog {
+  if (_rateThisAppDialog.get()) {
+    base::RecordAction(base::UserMetricsAction(
+        "IOSRateThisAppDialogDismissedProgramatically"));
+    [_rateThisAppDialog dismiss];
+    _rateThisAppDialog.reset();
+  }
+}
+
+#if !defined(NDEBUG)
+- (void)viewSource {
+  Tab* tab = [_model currentTab];
+  DCHECK(tab);
+  CRWWebController* webController = tab.webController;
+  NSString* script = @"document.documentElement.outerHTML;";
+  base::WeakNSObject<Tab> weakTab(tab);
+  web::JavaScriptResultBlock completionHandlerBlock = ^(id result, NSError*) {
+    base::scoped_nsobject<Tab> strongTab([weakTab retain]);
+    if (!strongTab)
+      return;
+    if (![result isKindOfClass:[NSString class]])
+      result = @"Not an HTML page";
+    std::string base64HTML;
+    base::Base64Encode(base::SysNSStringToUTF8(result), &base64HTML);
+    GURL URL(std::string("data:text/plain;charset=utf-8;base64,") + base64HTML);
+    web::Referrer referrer([strongTab url], web::ReferrerPolicyDefault);
+    [strongTab webPageOrderedOpen:URL
+                         referrer:referrer
+                       windowName:nil
+                     inBackground:NO];
+  };
+  [webController executeJavaScript:script
+                 completionHandler:completionHandlerBlock];
+}
+#endif  // !defined(NDEBUG)
+
+- (void)startVoiceSearch {
+  // Delay Voice Search until new tab animations have finished.
+  if (_inNewTabAnimation) {
+    _startVoiceSearchAfterNewTabAnimation = YES;
+    return;
+  }
+
+  // Keyboard shouldn't overlay the ecoutez window, so dismiss find in page and
+  // dismiss the keyboard.
+  [self closeFindInPage];
+  [[_model currentTab].webController dismissKeyboard];
+
+  // Ensure that voice search objects are created.
+  [self ensureVoiceSearchControllerCreated];
+  [self ensureVoiceSearchBarCreated];
+
+  // Present voice search.
+  [_voiceSearchBar prepareToPresentVoiceSearch];
+  _voiceSearchController->StartRecognition(self, [_model currentTab]);
+  [_toolbarController cancelOmniboxEdit];
+}
+
+#pragma mark - ToolbarOwner
+
+- (ToolbarController*)relinquishedToolbarController {
+  if (_isToolbarControllerRelinquished)
+    return nil;
+
+  ToolbarController* relinquishedToolbarController = nil;
+  if ([_toolbarController view].hidden) {
+    Tab* currentTab = [_model currentTab];
+    if (currentTab && UrlHasChromeScheme(currentTab.url)) {
+      // Use the native content controller's toolbar when the BVC's is hidden.
+      id nativeController = [self nativeControllerForTab:currentTab];
+      if ([nativeController conformsToProtocol:@protocol(ToolbarOwner)]) {
+        relinquishedToolbarController =
+            [nativeController relinquishedToolbarController];
+        _relinquishedToolbarOwner.reset(nativeController);
+      }
+    }
+  } else {
+    relinquishedToolbarController = _toolbarController.get();
+  }
+  _isToolbarControllerRelinquished = (relinquishedToolbarController != nil);
+  return relinquishedToolbarController;
+}
+
+- (void)reparentToolbarController {
+  if (_isToolbarControllerRelinquished) {
+    if ([[_toolbarController view] isDescendantOfView:self.view]) {
+      // A native content controller's toolbar has been relinquished.
+      [_relinquishedToolbarOwner reparentToolbarController];
+      _relinquishedToolbarOwner.reset();
+    } else if ([_findBarController isFindInPageShown]) {
+      [self.view insertSubview:[_toolbarController view]
+                  belowSubview:[_findBarController view]];
+    } else {
+      [self.view addSubview:[_toolbarController view]];
+    }
+    if (_contextualSearchPanel) {
+      // Move panel back into its correct place.
+      [self.view insertSubview:_contextualSearchPanel
+                  aboveSubview:[_toolbarController view]];
+    }
+    _isToolbarControllerRelinquished = NO;
+  }
+}
+
+#pragma mark - TabModelObserver methods
+
+// Observer method, tab inserted.
+- (void)tabModel:(TabModel*)model
+    didInsertTab:(Tab*)tab
+         atIndex:(NSUInteger)modelIndex
+    inForeground:(BOOL)fg {
+  DCHECK(tab);
+  [self installDelegatesForTab:tab];
+
+  if (fg) {
+    [_contextualSearchController setTab:tab];
+    [_paymentRequestManager setWebState:tab.webState];
+  }
+}
+
+// Observer method, active tab changed.
+- (void)tabModel:(TabModel*)model
+    didChangeActiveTab:(Tab*)newTab
+           previousTab:(Tab*)previousTab
+               atIndex:(NSUInteger)index {
+  // TODO(rohitrao): tabSelected expects to always be called with a non-nil tab.
+  // Currently this observer method is always called with a non-nil |newTab|,
+  // but that may change in the future.  Remove this DCHECK when it does.
+  DCHECK(newTab);
+  if (_infoBarContainer.get()) {
+    infobars::InfoBarManager* infoBarManager = [newTab infoBarManager];
+    _infoBarContainer->ChangeInfoBarManager(infoBarManager);
+  }
+  [self updateVoiceSearchBarVisibilityAnimated:NO];
+
+  [_contextualSearchController setTab:newTab];
+  [_paymentRequestManager setWebState:newTab.webState];
+
+  [self tabSelected:newTab];
+  DCHECK_EQ(newTab, [model currentTab]);
+  [self installDelegatesForTab:newTab];
+}
+
+// Observer method, tab changed.
+- (void)tabModel:(TabModel*)model didChangeTab:(Tab*)tab {
+  DCHECK(tab && ([_model indexOfTab:tab] != NSNotFound));
+  if (tab == [_model currentTab]) {
+    [self updateToolbar];
+    // Disable contextual search when |tab| is a voice search result tab.
+    BOOL enableContextualSearch = self.active && !tab.isVoiceSearchResultsTab;
+    [_contextualSearchController enableContextualSearch:enableContextualSearch];
+  }
+}
+
+// A tab has been removed, remove its views from display if necessary.
+- (void)tabModel:(TabModel*)model
+    didRemoveTab:(Tab*)tab
+         atIndex:(NSUInteger)index {
+  // Remove stored native controllers for the tab.
+  [_nativeControllersForTabIDs removeObjectForKey:tab.tabId];
+
+  // Ignore changes while the tab stack view is visible (or while suspended).
+  // The display will be refreshed when this view becomes active again.
+  if (!self.visible || !model.webUsageEnabled)
+    return;
+
+  // Remove the find bar for now.
+  [self hideFindBarWithAnimation:NO];
+}
+
+- (void)tabModel:(TabModel*)model willRemoveTab:(Tab*)tab {
+  if (tab == [model currentTab]) {
+    [_contentArea displayContentView:nil];
+    [_toolbarController selectedTabChanged];
+  }
+
+  [[UpgradeCenter sharedInstance] tabWillClose:tab.tabId];
+  if ([model count] == 1) {  // About to remove the last tab.
+    [_contextualSearchController setTab:nil];
+    [_paymentRequestManager setWebState:nil];
+  }
+}
+
+// Called when the number of tabs changes. Update the toolbar accordingly.
+- (void)tabModelDidChangeTabCount:(TabModel*)model {
+  DCHECK(model == _model);
+  if ([_model count] == 1 && _noTabsController.get()) {
+    [self dismissNoTabsUI];
+  }
+
+  [_toolbarController setTabCount:[_model count]];
+  // If the iPad tab switcher feature is enabled, the tab switcher is shown
+  // instead of the no tabs UI. Showing the tab switcher in that case is
+  // done from the main controller.
+  // If the iPad tab switcher feature is disabled and the number of tabs is
+  // zero, ensure the no-tabs UI is visible (such as if the last tab was closed
+  // programmatically from JS).  This is done on a delay because the
+  // notification happens while the tab is going away and trying to trigger a
+  // change during teardown causes problems.
+  BOOL showNoTabsUIOnIPad =
+      IsIPadIdiom() && !experimental_flags::IsTabSwitcherEnabled();
+  if (![_model count] && showNoTabsUIOnIPad && !_isOffTheRecord) {
+    [self performSelector:@selector(showNoTabsUI)
+               withObject:nil
+               afterDelay:0.01];
+  }
+}
+
+#pragma mark - Upgrade Detection
+
+- (void)showUpgrade:(UpgradeCenter*)center {
+  // Add an infobar on all the open tabs.
+  for (Tab* tab in _model.get()) {
+    NSString* tabId = tab.tabId;
+    DCHECK([tab infoBarManager]);
+    [center addInfoBarToManager:[tab infoBarManager] forTabId:tabId];
+  }
+}
+
+#pragma mark - ContextualSearchControllerDelegate
+
+- (void)createTabFromContextualSearchController:(const GURL&)url {
+  Tab* currentTab = [_model currentTab];
+  DCHECK(currentTab);
+  NSUInteger index = [_model indexOfTab:currentTab];
+  [self addSelectedTabWithURL:url
+                      atIndex:index + 1
+                   transition:ui::PAGE_TRANSITION_LINK];
+}
+
+- (void)promotePanelToTabProvidedBy:(id<ContextualSearchTabProvider>)tabProvider
+                         focusInput:(BOOL)focusInput {
+  // Tell the panel it will be promoted.
+  ContextualSearchPanelView* promotingPanel = _contextualSearchPanel;
+  [promotingPanel prepareForPromotion];
+
+  // Make a new panel and tell the controller about it.
+  _contextualSearchPanel = [self createPanelView];
+  [self.view insertSubview:_contextualSearchPanel belowSubview:promotingPanel];
+  [_contextualSearchController setPanel:_contextualSearchPanel];
+
+  // Figure out vertical offset.
+  CGFloat offset = StatusBarHeight();
+  if (IsIPadIdiom()) {
+    offset = MAX(offset, CGRectGetMaxY([_tabStripController view].frame));
+  }
+
+  // Transition steps: Animate the panel position, fade in the toolbar and
+  // tab strip.
+  ProceduralBlock transition = ^{
+    [promotingPanel promoteToMatchSuperviewWithVerticalOffset:offset];
+    [self updateToolbarControlsAlpha:1.0];
+    [self updateToolbarBackgroundAlpha:1.0];
+    [_tabStripController view].alpha = 1.0;
+  };
+
+  // After the transition animation completes, add the tab to the tab model
+  // (on iPad this triggers the tab strip animation too), then fade out the
+  // transitioning panel and remove it.
+  void (^completion)(BOOL) = ^(BOOL finished) {
+    _contextualSearchMask.alpha = 0;
+    Tab* newTab = [tabProvider releaseTab];
+    DCHECK(newTab);
+    DCHECK([newTab navigationManager]);
+    // Add the new tab to the tab model.
+    [newTab setParentTabModel:_model];
+    // Insert the new tab one after the current tab.
+    Tab* currentTab = [_model currentTab];
+    NSUInteger index = [_model indexOfTab:currentTab];
+    [_model insertTab:newTab atIndex:index + 1];
+
+    // Set isPrerenderTab to NO after inserting the tab. This will allow the
+    // BrowserViewController to detect that a pre-rendered tab is switched in,
+    // and show the prerendering animation. This needs to happen before the
+    // tab is made the current tab.
+    // This also enables contextual search (if otherwise applicable) on
+    // |newTab|.
+    newTab.isPrerenderTab = NO;
+    [_model setCurrentTab:newTab];
+
+    BOOL loadingFinished = [newTab.webController loadPhase] == web::PAGE_LOADED;
+    if (loadingFinished)
+      [self tabLoadComplete:newTab withSuccess:YES];
+
+    if (focusInput) {
+      [_toolbarController focusOmnibox];
+    }
+    _infoBarContainer->RestoreInfobars();
+
+    [UIView animateWithDuration:ios::material::kDuration2
+        animations:^{
+          promotingPanel.alpha = 0;
+        }
+        completion:^(BOOL finished) {
+          [promotingPanel removeFromSuperview];
+        }];
+  };
+
+  [UIView animateWithDuration:ios::material::kDuration3
+                   animations:transition
+                   completion:completion];
+}
+
+- (ContextualSearchPanelView*)createPanelView {
+  PanelConfiguration* config;
+  CGSize panelContainerSize = self.view.bounds.size;
+  if (IsIPadIdiom()) {
+    config = [PadPanelConfiguration
+        configurationForContainerSize:panelContainerSize
+                  horizontalSizeClass:self.traitCollection.horizontalSizeClass];
+  } else {
+    config = [PhonePanelConfiguration
+        configurationForContainerSize:panelContainerSize
+                  horizontalSizeClass:self.traitCollection.horizontalSizeClass];
+  }
+  ContextualSearchPanelView* newPanel = [[[ContextualSearchPanelView alloc]
+      initWithConfiguration:config] autorelease];
+  [newPanel addMotionObserver:self];
+  [newPanel addMotionObserver:_contextualSearchMask];
+  return newPanel;
+}
+
+#pragma mark - ContextualSearchPanelMotionObserver
+
+- (void)panel:(ContextualSearchPanelView*)panel
+    didMoveWithMotion:(ContextualSearch::PanelMotion)motion {
+  // If the header is offset, it's offscreen (or moving offscreen) and the
+  // toolbar shouldn't be opacity-adjusted by the contextual search panel.
+  if ([self currentHeaderOffset] != 0)
+    return;
+
+  CGFloat toolbarAlpha;
+
+  if (motion.state == ContextualSearch::PREVIEWING) {
+    // As the panel moves past the previewing position, the toolbar should
+    // become more transparent.
+    toolbarAlpha = 1 - motion.gradation;
+  } else if (motion.state == ContextualSearch::COVERING) {
+    // The toolbar should be totally transparent when the panel is covering.
+    toolbarAlpha = 0.0;
+  } else {
+    return;
+  }
+
+  // On iPad, the toolbar doesn't go fully transparent, so map |toolbarAlpha|'s
+  // [0-1.0] range to [0.5-1.0].
+  if (IsIPadIdiom()) {
+    toolbarAlpha = 0.5 + (toolbarAlpha * 0.5);
+    [_tabStripController view].alpha = toolbarAlpha;
+  }
+
+  [self updateToolbarControlsAlpha:toolbarAlpha];
+  [self updateToolbarBackgroundAlpha:toolbarAlpha];
+}
+
+- (void)panel:(ContextualSearchPanelView*)panel
+    didChangeToState:(ContextualSearch::PanelState)toState
+           fromState:(ContextualSearch::PanelState)fromState {
+  if (toState == ContextualSearch::DISMISSED) {
+    // Panel has become hidden.
+    _infoBarContainer->RestoreInfobars();
+    [self updateToolbarControlsAlpha:1.0];
+    [self updateToolbarBackgroundAlpha:1.0];
+    [_tabStripController view].alpha = 1.0;
+  } else if (fromState == ContextualSearch::DISMISSED) {
+    // Panel has become visible.
+    _infoBarContainer->SuspendInfobars();
+  }
+}
+
+- (void)panelWillPromote:(ContextualSearchPanelView*)panel {
+  [panel removeMotionObserver:self];
+}
+
+- (CGFloat)currentHeaderHeight {
+  return [self headerHeight] - [self currentHeaderOffset];
+}
+
+#pragma mark - InfoBarControllerDelegate
+
+- (void)infoBarContainerStateChanged:(bool)isAnimating {
+  InfoBarContainerView* infoBarContainerView = _infoBarContainer->view();
+  DCHECK(infoBarContainerView);
+  CGRect containerFrame = infoBarContainerView.frame;
+  CGFloat height = [infoBarContainerView topmostVisibleInfoBarHeight];
+  containerFrame.origin.y = CGRectGetMaxY(_contentArea.frame) - height;
+  containerFrame.size.height = height;
+  BOOL isViewVisible = self.visible;
+  [UIView animateWithDuration:0.1
+      animations:^{
+        [infoBarContainerView setFrame:containerFrame];
+      }
+      completion:^(BOOL finished) {
+        if (!isViewVisible)
+          return;
+        UIAccessibilityPostNotification(
+            UIAccessibilityLayoutChangedNotification, infoBarContainerView);
+      }];
+}
+
+- (BOOL)shouldAutorotate {
+  if (_voiceSearchController && _voiceSearchController->IsVisible()) {
+    // Don't rotate if a voice search is being presented or dismissed.  Once the
+    // transition animations finish, only the Voice Search UIViewController's
+    // |-shouldAutorotate| will be called.
+    return NO;
+  } else if (_sideSwipeController && ![_sideSwipeController shouldAutorotate]) {
+    // Don't auto rotate if side swipe controller view says not to.
+    return NO;
+  } else {
+    return [super shouldAutorotate];
+  }
+}
+
+// Always return yes, as this tap should work with various recognizers,
+// including UITextTapRecognizer, UILongPressGestureRecognizer,
+// UIScrollViewPanGestureRecognizer and others.
+- (BOOL)gestureRecognizer:(UIGestureRecognizer*)gestureRecognizer
+    shouldRecognizeSimultaneouslyWithGestureRecognizer:
+        (UIGestureRecognizer*)otherGestureRecognizer {
+  return YES;
+}
+
+// Tap gestures should only be recognized within |_contentArea|.
+- (BOOL)gestureRecognizerShouldBegin:(UIGestureRecognizer*)gesture {
+  CGPoint location = [gesture locationInView:self.view];
+
+  // Only allow touches on descendant views of |_contentArea|.
+  UIView* hitView = [self.view hitTest:location withEvent:nil];
+  return (![hitView isDescendantOfView:_contentArea]) ? NO : YES;
+}
+
+#pragma mark - SideSwipeController Delegate Methods
+
+- (void)sideSwipeViewDismissAnimationDidEnd:(UIView*)sideSwipeView {
+  DCHECK(!IsIPadIdiom());
+  // Update frame incase orientation changed while |_contentArea| was out of
+  // the view hierarchy.
+  [_contentArea setFrame:[sideSwipeView frame]];
+
+  [self.view insertSubview:_contentArea atIndex:0];
+  [self updateVoiceSearchBarVisibilityAnimated:NO];
+  [self updateToolbar];
+
+  // Reset horizontal stack view.
+  [sideSwipeView removeFromSuperview];
+  [_sideSwipeController setInSwipe:NO];
+  [_infoBarContainer->view() setHidden:NO];
+}
+
+- (UIView*)contentView {
+  return _contentArea;
+}
+
+- (TabStripController*)tabStripController {
+  return _tabStripController;
+}
+
+- (WebToolbarController*)toolbarController {
+  return _toolbarController;
+}
+
+- (BOOL)preventSideSwipe {
+  if ([_toolbarController toolsPopupController])
+    return YES;
+
+  if (_voiceSearchController && _voiceSearchController->IsVisible())
+    return YES;
+
+  if ([_contextualSearchPanel state] >= ContextualSearch::PEEKING)
+    return YES;
+
+  if (!self.active)
+    return YES;
+
+  return NO;
+}
+
+- (void)updateAccessoryViewsForSideSwipeWithVisibility:(BOOL)visible {
+  if (visible) {
+    [self updateVoiceSearchBarVisibilityAnimated:NO];
+    [self updateToolbar];
+    [_infoBarContainer->view() setHidden:NO];
+  } else {
+    // Hide UI accessories such as find bar and first visit overlays
+    // for welcome page.
+    [self hideFindBarWithAnimation:NO];
+    [_infoBarContainer->view() setHidden:YES];
+    [_voiceSearchBar setHidden:YES];
+  }
+}
+
+- (BOOL)verifyToolbarViewPlacementInView:(UIView*)views {
+  BOOL seenToolbar = NO;
+  BOOL seenInfoBarContainer = NO;
+  BOOL seenContentArea = NO;
+  for (UIView* view in views.subviews) {
+    if (view == [_toolbarController view])
+      seenToolbar = YES;
+    else if (view == _infoBarContainer->view())
+      seenInfoBarContainer = YES;
+    else if (view == _contentArea)
+      seenContentArea = YES;
+    if ((seenToolbar && !seenInfoBarContainer) ||
+        (seenInfoBarContainer && !seenContentArea))
+      return NO;
+  }
+  return YES;
+}
+
+#pragma mark - PreloadControllerDelegate methods
+
+- (BOOL)shouldUseDesktopUserAgent {
+  return [_model currentTab].useDesktopUserAgent;
+}
+
+- (CRWSessionEntry*)currentSessionEntry {
+  Tab* tab = [_model currentTab];
+  if (![tab navigationManager])
+    return nil;
+  return [[tab navigationManager]->GetSessionController() currentEntry];
+}
+
+#pragma mark - BookmarkBridgeMethods
+
+// If an added or removed bookmark is the same as the current url, update the
+// toolbar so the star highlight is kept in sync.
+- (void)bookmarkNodeModified:(const BookmarkNode*)node {
+  if ([_model currentTab] && node->url() == [_model currentTab].url)
+    [self updateToolbar];
+}
+
+// If all bookmarks are removed, update the toolbar so the star highlight is
+// kept in sync.
+- (void)allBookmarksRemoved {
+  [self updateToolbar];
+}
+
+#pragma mark - ShareToDelegate methods
+
+- (void)shareDidComplete:(ShareTo::ShareResult)shareStatus
+          successMessage:(NSString*)message {
+  // The shareTo dialog dismisses itself instead of through
+  // |-dismissViewControllerAnimated:completion:| so we must reset the
+  // presenting state here.
+  self.presenting = NO;
+  [self.dialogPresenter tryToPresent];
+
+  switch (shareStatus) {
+    case ShareTo::SHARE_SUCCESS:
+      if ([message length])
+        [self showSnackbar:message];
+      break;
+    case ShareTo::SHARE_ERROR:
+      [self showErrorAlert:IDS_IOS_SHARE_TO_ERROR_ALERT_TITLE
+                   message:IDS_IOS_SHARE_TO_ERROR_ALERT];
+      break;
+    case ShareTo::SHARE_NETWORK_FAILURE:
+      [self showErrorAlert:IDS_IOS_SHARE_TO_NETWORK_ERROR_ALERT_TITLE
+                   message:IDS_IOS_SHARE_TO_NETWORK_ERROR_ALERT];
+      break;
+    case ShareTo::SHARE_SIGN_IN_FAILURE:
+      [self showErrorAlert:IDS_IOS_SHARE_TO_SIGN_IN_ERROR_ALERT_TITLE
+                   message:IDS_IOS_SHARE_TO_SIGN_IN_ERROR_ALERT];
+      break;
+    case ShareTo::SHARE_CANCEL:
+    case ShareTo::SHARE_UNKNOWN_RESULT:
+      break;
+  }
+}
+
+- (void)passwordAppExDidFinish:(ShareTo::ShareResult)shareStatus
+                      username:(NSString*)username
+                      password:(NSString*)password
+                successMessage:(NSString*)message {
+  switch (shareStatus) {
+    case ShareTo::SHARE_SUCCESS: {
+      PasswordController* passwordController =
+          [[_model currentTab] passwordController];
+      __block BOOL shown = NO;
+      [passwordController findAndFillPasswordForms:username
+                                          password:password
+                                 completionHandler:^(BOOL completed) {
+                                   if (shown || !completed || ![message length])
+                                     return;
+                                   [self showSnackbar:message];
+                                   shown = YES;
+                                 }];
+      break;
+    }
+    default:
+      break;
+  }
+}
+
+- (void)showErrorAlert:(int)titleMessageId message:(int)messageId {
+  NSString* title = l10n_util::GetNSString(titleMessageId);
+  NSString* message = l10n_util::GetNSString(messageId);
+  [self showErrorAlertWithStringTitle:title message:message];
+}
+
+- (void)showErrorAlertWithStringTitle:(NSString*)title
+                              message:(NSString*)message {
+  // Dismiss current alert.
+  [_alertCoordinator stop];
+
+  _alertCoordinator.reset(
+      [[_dependencyFactory alertCoordinatorWithTitle:title
+                                             message:message
+                                      viewController:self] retain]);
+  [_alertCoordinator start];
+}
+
+- (void)showSnackbar:(NSString*)message {
+  [_dependencyFactory showSnackbarWithMessage:message];
+}
+
+#pragma mark - Show Mail Composer methods
+
+- (void)showMailComposer:(id)sender {
+  ShowMailComposerCommand* command = (ShowMailComposerCommand*)sender;
+  if (![MFMailComposeViewController canSendMail]) {
+    NSString* alertTitle =
+        l10n_util::GetNSString([command emailNotConfiguredAlertTitleId]);
+    NSString* alertMessage =
+        l10n_util::GetNSString([command emailNotConfiguredAlertMessageId]);
+    [self showErrorAlertWithStringTitle:alertTitle message:alertMessage];
+    return;
+  }
+  base::scoped_nsobject<MFMailComposeViewController> mailViewController(
+      [[MFMailComposeViewController alloc] init]);
+  [mailViewController setModalPresentationStyle:UIModalPresentationFormSheet];
+  [mailViewController setToRecipients:[command toRecipients]];
+  [mailViewController setSubject:[command subject]];
+  [mailViewController setMessageBody:[command body] isHTML:NO];
+
+  const base::FilePath& textFile = [command textFileToAttach];
+  if (!textFile.empty()) {
+    NSString* filename = base::SysUTF8ToNSString(textFile.value());
+    NSData* data = [NSData dataWithContentsOfFile:filename];
+    if (data) {
+      NSString* displayName =
+          base::SysUTF8ToNSString(textFile.BaseName().value());
+      [mailViewController addAttachmentData:data
+                                   mimeType:@"text/plain"
+                                   fileName:displayName];
+    }
+  }
+
+  [mailViewController setMailComposeDelegate:self];
+  [self presentViewController:mailViewController animated:YES completion:nil];
+}
+
+#pragma mark - MFMailComposeViewControllerDelegate methods
+
+- (void)mailComposeController:(MFMailComposeViewController*)controller
+          didFinishWithResult:(MFMailComposeResult)result
+                        error:(NSError*)error {
+  [self dismissViewControllerAnimated:YES completion:nil];
+}
+
+#pragma mark - StoreKitLauncher methods
+
+- (void)productViewControllerDidFinish:
+    (SKStoreProductViewController*)viewController {
+  [self dismissViewControllerAnimated:YES completion:nil];
+}
+
+- (void)openAppStore:(NSString*)appId {
+  if (![appId length])
+    return;
+  NSDictionary* product =
+      @{SKStoreProductParameterITunesItemIdentifier : appId};
+  base::scoped_nsobject<SKStoreProductViewController> storeViewController(
+      [[SKStoreProductViewController alloc] init]);
+  [storeViewController setDelegate:self];
+  [storeViewController loadProductWithParameters:product completionBlock:nil];
+  [self presentViewController:storeViewController animated:YES completion:nil];
+}
+
+#pragma mark - TabDialogDelegate methods
+
+- (void)tab:(Tab*)tab
+    runAuthDialogForProtectionSpace:(NSURLProtectionSpace*)protectionSpace
+                 proposedCredential:(NSURLCredential*)credential
+                  completionHandler:
+                      (void (^)(NSString* user, NSString* password))handler {
+  [self.dialogPresenter runAuthDialogForProtectionSpace:protectionSpace
+                                     proposedCredential:credential
+                                               webState:tab.webState
+                                      completionHandler:handler];
+}
+
+- (void)cancelDialogForTab:(Tab*)tab {
+  [self.dialogPresenter cancelDialogForWebState:tab.webState];
+}
+
+#pragma mark - FKFeedbackPromptDelegate methods
+
+- (void)userTappedRateApp:(UIView*)view {
+  base::RecordAction(base::UserMetricsAction("IOSRateThisAppRateChosen"));
+  _rateThisAppDialog.reset();
+}
+
+- (void)userTappedSendFeedback:(UIView*)view {
+  base::RecordAction(base::UserMetricsAction("IOSRateThisAppFeedbackChosen"));
+  _rateThisAppDialog.reset();
+  base::scoped_nsobject<GenericChromeCommand> command(
+      [[GenericChromeCommand alloc] initWithTag:IDC_REPORT_AN_ISSUE]);
+  [self chromeExecuteCommand:command];
+}
+
+- (void)userTappedDismiss:(UIView*)view {
+  base::RecordAction(base::UserMetricsAction("IOSRateThisAppDismissChosen"));
+  _rateThisAppDialog.reset();
+}
+
+#pragma mark - VoiceSearchBarDelegate
+
+- (BOOL)isTTSEnabledForVoiceSearchBar:(id<VoiceSearchBar>)voiceSearchBar {
+  DCHECK_EQ(_voiceSearchBar.get(), voiceSearchBar);
+  [self ensureVoiceSearchControllerCreated];
+  return _voiceSearchController->IsTextToSpeechEnabled() &&
+         _voiceSearchController->IsTextToSpeechSupported();
+}
+
+- (void)voiceSearchBarDidUpdateButtonState:(id<VoiceSearchBar>)voiceSearchBar {
+  DCHECK_EQ(_voiceSearchBar.get(), voiceSearchBar);
+  [self.tabModel.currentTab updateSnapshotWithOverlay:YES visibleFrameOnly:YES];
+}
+
+#pragma mark - VoiceSearchPresenter
+
+- (UIView*)voiceSearchButton {
+  return _voiceSearchButton;
+}
+
+- (id<LogoAnimationControllerOwner>)logoAnimationControllerOwner {
+  return [self currentLogoAnimationControllerOwner];
+}
+
+@end