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