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/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_headers_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_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/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";

}  // anonymous namespace

@interface BrowserViewController ()<AppRatingPromptDelegate,
                                    ContextualSearchControllerDelegate,
                                    ContextualSearchPanelMotionObserver,
                                    CRWNativeContentProvider,
                                    CRWWebStateDelegate,
                                    DialogPresenterDelegate,
                                    FullScreenControllerDelegate,
                                    KeyCommandsPlumbing,
                                    MFMailComposeViewControllerDelegate,
                                    NewTabPageControllerObserver,
                                    OverscrollActionsControllerDelegate,
                                    PassKitDialogProvider,
                                    PreloadControllerDelegate,
                                    ShareToDelegate,
                                    SKStoreProductViewControllerDelegate,
                                    SnapshotOverlayProvider,
                                    StoreKitLauncher,
                                    TabDialogDelegate,
                                    TabHeadersDelegate,
                                    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.
  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;
// Returns Tab that corresponds to the given |webState|.
- (Tab*)tabForWebState:(web::WebState*)webState;
// Saves the image or display error message, based on privacy settings.
- (void)managePermissionAndSaveImage:(NSData*)data;
// 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;
// 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;
// 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;
    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();
  if (_bookmarkModel)
    _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();
}

- (ios::ChromeBrowserState*)browserState {
  return _browserState;
}

- (TabModel*)tabModel {
  return _model.get();
}

- (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 {
  CGRect initialViewsRect = self.view.frame;
  initialViewsRect.origin.y += StatusBarHeight();
  initialViewsRect.size.height -= StatusBarHeight();
  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.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;
  if ([_sideSwipeController inSwipe]) {
    [_sideSwipeController resetContentView];
  }

  [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;
          // Use the model's currentTab here because it is possible that it can
          // be reset to a new value before the new Tab animation finished (e.g.
          // if another Tab shows a dialog via |dialogPresenter|). However, that
          // tab's view hasn't been displayed yet because it was in a new tab
          // animation.
          Tab* currentTab = [_model currentTab];
          if (currentTab) {
            [self tabSelected:currentTab];
          }
          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 (BookmarkModel may be null
  // during testing, so explicitly support this).
  _bookmarkModel = ios::BookmarkModelFactory::GetForBrowserState(_browserState);
  if (_bookmarkModel) {
    _bookmarkModelBridge.reset(new BrowserBookmarkModelBridge(self));
    _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();
  [_toolbarController browserStateDestroyed];
  [_model browserStateDestroyed];
  [_preloadController browserStateDestroyed];
  _preloadController.reset();
  // 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.tabHeadersDelegate = 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 || !_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()
                             ->BuildVoiceSearchBar(frame) retain]);
  [_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.

- (web::WebState*)webState:(web::WebState*)webState
         openURLWithParams:(const web::WebState::OpenURLParams&)params {
  switch (params.disposition) {
    case WindowOpenDisposition::NEW_FOREGROUND_TAB:
    case WindowOpenDisposition::NEW_BACKGROUND_TAB: {
      Tab* tab = [[self tabModel]
          insertOrUpdateTabWithURL:params.url
                          referrer:params.referrer
                        transition:params.transition
                        windowName:nil
                            opener:[self tabForWebState:webState]
                       openedByDOM:NO
                           atIndex:TabModelConstants::kTabPositionAutomatically
                      inBackground:(params.disposition ==
                                    WindowOpenDisposition::NEW_BACKGROUND_TAB)];
      return tab.webState;
    }
    case WindowOpenDisposition::CURRENT_TAB: {
      web::NavigationManager::WebLoadParams loadParams(params.url);
      loadParams.referrer = params.referrer;
      loadParams.transition_type = params.transition;
      loadParams.is_renderer_initiated = params.is_renderer_initiated;
      webState->GetNavigationManager()->LoadURLWithParams(loadParams);
      return webState;
    }
    default:
      NOTIMPLEMENTED();
      return nullptr;
  };
}

- (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);

      // 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];
      }
    }
    if (link.SchemeIsHTTPOrHTTPS() &&
        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];
      }
    }
    // 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();
}

- (void)webState:(web::WebState*)webState
    didRequestHTTPAuthForProtectionSpace:(NSURLProtectionSpace*)protectionSpace
                      proposedCredential:(NSURLCredential*)proposedCredential
                       completionHandler:(void (^)(NSString* username,
                                                   NSString* password))handler {
  [self.dialogPresenter runAuthDialogForProtectionSpace:protectionSpace
                                     proposedCredential:proposedCredential
                                               webState:webState
                                      completionHandler:handler];
}

#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].tabId];
}

- (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];
}

- (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];
    [controller setDelegate:self];
    OverscrollStyle style = _isOffTheRecord
                                ? OverscrollStyle::REGULAR_PAGE_INCOGNITO
                                : OverscrollStyle::REGULAR_PAGE_NON_INCOGNITO;
    controller.style = style;
    nativeContent.overscrollActionsController = controller;
  }
}

#pragma mark - OverscrollActionsControllerDelegate methods.

- (void)overscrollActionsController:(OverscrollActionsController*)controller
                   didTriggerAction:(OverscrollAction)action {
  switch (action) {
    case OverscrollAction::NEW_TAB:
      [self newTab:nil];
      break;
    case OverscrollAction::CLOSE_TAB:
      [self closeCurrentTab];
      break;
    case OverscrollAction::REFRESH:
      if ([[[_model currentTab] webController] loadPhase] ==
          web::PAGE_LOADING) {
        [[_model currentTab] stopLoading];
      }
      [[_model currentTab] reload];
      break;
    case 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());

  web::ImageFetchedCallback callback =
      ^(const GURL& original_url, int response_code, NSData* data) {
        DCHECK(data);

        [self managePermissionAndSaveImage:data];
      };
  _imageFetcher->StartDownload(
      url, callback, web::ReferrerHeaderValueForNavigation(url, referrer),
      web::PolicyForNavigation(url, referrer));
}

- (void)managePermissionAndSaveImage:(NSData*)data {
  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];
      }];
      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];
                               }));
      break;
    }
  }
}

- (void)saveImage:(NSData*)data {
  NSString* fileName = [[[NSProcessInfo processInfo] globallyUniqueString]
      stringByAppendingString:@".png"];
  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 - 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),
                         reading_list::ADDED_VIA_CURRENT_APP);

  [self showSnackbar:l10n_util::GetNSString(
                         IDS_IOS_READING_LIST_SNACKBAR_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];
}

- (BOOL)canGoBack {
  return [_model currentTab].canGoBack;
}

- (BOOL)canGoForward {
  return [_model currentTab].canGoForward;
}

- (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];
}

- (Tab*)tabForWebState:(web::WebState*)webState {
  for (Tab* tab in _model.get()) {
    if (tab.webState == webState)
      return tab;
  }
  return nil;
}

// 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 {
  DCHECK(javascript);
  javascript = [javascript stringByRemovingPercentEncoding];
  web::WebState* webState = [[_model currentTab] webState];
  if (webState) {
    webState->ExecuteJavaScript(base::SysNSStringToUTF16(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)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