forked from chromium/chromium
-
Notifications
You must be signed in to change notification settings - Fork 0
/
Copy pathapp_controller_mac.mm
1327 lines (1183 loc) · 51.8 KB
/
app_controller_mac.mm
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
// Copyright (c) 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 "chrome/browser/app_controller_mac.h"
#include "base/auto_reset.h"
#include "base/bind.h"
#include "base/command_line.h"
#include "base/file_path.h"
#include "base/mac/foundation_util.h"
#include "base/mac/mac_util.h"
#include "base/message_loop.h"
#include "base/string_number_conversions.h"
#include "base/sys_string_conversions.h"
#include "base/utf_string_conversions.h"
#include "chrome/app/chrome_command_ids.h"
#include "chrome/browser/background/background_application_list_model.h"
#include "chrome/browser/background/background_mode_manager.h"
#include "chrome/browser/browser_process.h"
#include "chrome/browser/browser_shutdown.h"
#include "chrome/browser/command_updater.h"
#include "chrome/browser/download/download_service.h"
#include "chrome/browser/download/download_service_factory.h"
#include "chrome/browser/first_run/first_run.h"
#include "chrome/browser/lifetime/application_lifetime.h"
#include "chrome/browser/prefs/pref_service.h"
#include "chrome/browser/printing/cloud_print/virtual_driver_install_helper.h"
#include "chrome/browser/printing/print_dialog_cloud.h"
#include "chrome/browser/profiles/profile_manager.h"
#include "chrome/browser/service/service_process_control.h"
#include "chrome/browser/sessions/session_service.h"
#include "chrome/browser/sessions/session_service_factory.h"
#include "chrome/browser/sessions/tab_restore_service.h"
#include "chrome/browser/sessions/tab_restore_service_factory.h"
#include "chrome/browser/sync/profile_sync_service.h"
#include "chrome/browser/sync/sync_ui_util.h"
#include "chrome/browser/sync/sync_ui_util_mac.h"
#include "chrome/browser/ui/browser.h"
#include "chrome/browser/ui/browser_commands.h"
#include "chrome/browser/ui/browser_finder.h"
#include "chrome/browser/ui/browser_list.h"
#include "chrome/browser/ui/browser_mac.h"
#include "chrome/browser/ui/browser_window.h"
#include "chrome/browser/ui/chrome_pages.h"
#import "chrome/browser/ui/cocoa/bookmarks/bookmark_menu_bridge.h"
#import "chrome/browser/ui/cocoa/browser_window_cocoa.h"
#import "chrome/browser/ui/cocoa/browser_window_controller.h"
#import "chrome/browser/ui/cocoa/confirm_quit.h"
#import "chrome/browser/ui/cocoa/confirm_quit_panel_controller.h"
#import "chrome/browser/ui/cocoa/encoding_menu_controller_delegate_mac.h"
#import "chrome/browser/ui/cocoa/history_menu_bridge.h"
#include "chrome/browser/ui/cocoa/last_active_browser_cocoa.h"
#import "chrome/browser/ui/cocoa/profile_menu_controller.h"
#import "chrome/browser/ui/cocoa/tabs/tab_strip_controller.h"
#import "chrome/browser/ui/cocoa/tabs/tab_window_controller.h"
#include "chrome/browser/ui/cocoa/task_manager_mac.h"
#include "chrome/browser/ui/startup/startup_browser_creator.h"
#include "chrome/browser/ui/startup/startup_browser_creator_impl.h"
#include "chrome/common/chrome_notification_types.h"
#include "chrome/common/chrome_paths_internal.h"
#include "chrome/common/chrome_switches.h"
#include "chrome/common/cloud_print/cloud_print_class_mac.h"
#include "chrome/common/mac/app_mode_common.h"
#include "chrome/common/pref_names.h"
#include "chrome/common/service_messages.h"
#include "chrome/common/url_constants.h"
#include "content/public/browser/browser_thread.h"
#include "content/public/browser/download_manager.h"
#include "content/public/browser/notification_service.h"
#include "content/public/browser/notification_types.h"
#include "content/public/browser/user_metrics.h"
#include "grit/chromium_strings.h"
#include "grit/generated_resources.h"
#include "net/base/net_util.h"
#include "ui/base/accelerators/accelerator_cocoa.h"
#include "ui/base/l10n/l10n_util.h"
#include "ui/base/l10n/l10n_util_mac.h"
using content::BrowserContext;
using content::BrowserThread;
using content::DownloadManager;
using content::UserMetricsAction;
// 10.6 adds a public API for the Spotlight-backed search menu item in the Help
// menu. Provide the declaration so it can be called below when building with
// the 10.5 SDK.
#if !defined(MAC_OS_X_VERSION_10_6) || \
MAC_OS_X_VERSION_MAX_ALLOWED < MAC_OS_X_VERSION_10_6
@interface NSApplication (SnowLeopardSDKDeclarations)
- (void)setHelpMenu:(NSMenu*)helpMenu;
@end
#endif
namespace {
// Declare notification names from the 10.7 SDK.
#if !defined(MAC_OS_X_VERSION_10_7) || \
MAC_OS_X_VERSION_MAX_ALLOWED < MAC_OS_X_VERSION_10_7
NSString* NSPopoverDidShowNotification = @"NSPopoverDidShowNotification";
NSString* NSPopoverDidCloseNotification = @"NSPopoverDidCloseNotification";
#endif
// True while AppController is calling chrome::NewEmptyWindow(). We need a
// global flag here, analogue to StartupBrowserCreator::InProcessStartup()
// because otherwise the SessionService will try to restore sessions when we
// make a new window while there are no other active windows.
bool g_is_opening_new_window = false;
// Activates a browser window having the given profile (the last one active) if
// possible and returns a pointer to the activate |Browser| or NULL if this was
// not possible. If the last active browser is minimized (in particular, if
// there are only minimized windows), it will unminimize it.
Browser* ActivateBrowser(Profile* profile) {
Browser* browser = browser::FindLastActiveWithProfile(profile);
if (browser)
browser->window()->Activate();
return browser;
}
// Creates an empty browser window with the given profile and returns a pointer
// to the new |Browser|.
Browser* CreateBrowser(Profile* profile) {
{
AutoReset<bool> auto_reset_in_run(&g_is_opening_new_window, true);
chrome::NewEmptyWindow(profile);
}
Browser* browser = browser::GetLastActiveBrowser();
CHECK(browser);
return browser;
}
// Activates a browser window having the given profile (the last one active) if
// possible or creates an empty one if necessary. Returns a pointer to the
// activated/new |Browser|.
Browser* ActivateOrCreateBrowser(Profile* profile) {
if (Browser* browser = ActivateBrowser(profile))
return browser;
return CreateBrowser(profile);
}
CFStringRef BaseBundleID_CFString() {
NSString* base_bundle_id =
[NSString stringWithUTF8String:base::mac::BaseBundleID()];
return base::mac::NSToCFCast(base_bundle_id);
}
// This callback synchronizes preferences (under "org.chromium.Chromium" or
// "com.google.Chrome"), in particular, writes them out to disk.
void PrefsSyncCallback() {
if (!CFPreferencesAppSynchronize(BaseBundleID_CFString()))
LOG(WARNING) << "Error recording application bundle path.";
}
// Record the location of the application bundle (containing the main framework)
// from which Chromium was loaded. This is used by app mode shims to find
// Chromium.
void RecordLastRunAppBundlePath() {
// Going up three levels from |chrome::GetVersionedDirectory()| gives the
// real, user-visible app bundle directory. (The alternatives give either the
// framework's path or the initial app's path, which may be an app mode shim
// or a unit test.)
FilePath appBundlePath =
chrome::GetVersionedDirectory().DirName().DirName().DirName();
CFPreferencesSetAppValue(
base::mac::NSToCFCast(app_mode::kLastRunAppBundlePathPrefsKey),
base::SysUTF8ToCFStringRef(appBundlePath.value()),
BaseBundleID_CFString());
// Sync after a delay avoid I/O contention on startup; 1500 ms is plenty.
BrowserThread::PostDelayedTask(
BrowserThread::FILE, FROM_HERE,
base::Bind(&PrefsSyncCallback),
base::TimeDelta::FromMilliseconds(1500));
}
} // anonymous namespace
const AEEventClass kAECloudPrintInstallClass = 'GCPi';
const AEEventClass kAECloudPrintUninstallClass = 'GCPu';
@interface AppController (Private)
- (void)initMenuState;
- (void)initProfileMenu;
- (void)updateConfirmToQuitPrefMenuItem:(NSMenuItem*)item;
- (void)registerServicesMenuTypesTo:(NSApplication*)app;
- (void)openUrls:(const std::vector<GURL>&)urls;
- (void)getUrl:(NSAppleEventDescriptor*)event
withReply:(NSAppleEventDescriptor*)reply;
- (void)submitCloudPrintJob:(NSAppleEventDescriptor*)event;
- (void)installCloudPrint:(NSAppleEventDescriptor*)event;
- (void)uninstallCloudPrint:(NSAppleEventDescriptor*)event;
- (void)windowLayeringDidChange:(NSNotification*)inNotification;
- (void)windowChangedToProfile:(Profile*)profile;
- (void)checkForAnyKeyWindows;
- (BOOL)userWillWaitForInProgressDownloads:(int)downloadCount;
- (BOOL)shouldQuitWithInProgressDownloads;
- (void)executeApplication:(id)sender;
@end
@implementation AppController
@synthesize startupComplete = startupComplete_;
// This method is called very early in application startup (ie, before
// the profile is loaded or any preferences have been registered). Defer any
// user-data initialization until -applicationDidFinishLaunching:.
- (void)awakeFromNib {
// We need to register the handlers early to catch events fired on launch.
NSAppleEventManager* em = [NSAppleEventManager sharedAppleEventManager];
[em setEventHandler:self
andSelector:@selector(getUrl:withReply:)
forEventClass:kInternetEventClass
andEventID:kAEGetURL];
[em setEventHandler:self
andSelector:@selector(submitCloudPrintJob:)
forEventClass:cloud_print::kAECloudPrintClass
andEventID:cloud_print::kAECloudPrintClass];
// Install and uninstall handlers for virtual drivers.
[em setEventHandler:self
andSelector:@selector(installCloudPrint:)
forEventClass:kAECloudPrintInstallClass
andEventID:kAECloudPrintInstallClass];
[em setEventHandler:self
andSelector:@selector(uninstallCloudPrint:)
forEventClass:kAECloudPrintUninstallClass
andEventID:kAECloudPrintUninstallClass];
[em setEventHandler:self
andSelector:@selector(getUrl:withReply:)
forEventClass:'WWW!' // A particularly ancient AppleEvent that dates
andEventID:'OURL']; // back to the Spyglass days.
// Register for various window layering changes. We use these to update
// various UI elements (command-key equivalents, etc) when the frontmost
// window changes.
NSNotificationCenter* notificationCenter =
[NSNotificationCenter defaultCenter];
[notificationCenter
addObserver:self
selector:@selector(windowLayeringDidChange:)
name:NSWindowDidBecomeKeyNotification
object:nil];
[notificationCenter
addObserver:self
selector:@selector(windowLayeringDidChange:)
name:NSWindowDidResignKeyNotification
object:nil];
[notificationCenter
addObserver:self
selector:@selector(windowLayeringDidChange:)
name:NSWindowDidBecomeMainNotification
object:nil];
[notificationCenter
addObserver:self
selector:@selector(windowLayeringDidChange:)
name:NSWindowDidResignMainNotification
object:nil];
if (base::mac::IsOSLionOrLater()) {
[notificationCenter
addObserver:self
selector:@selector(popoverDidShow:)
name:NSPopoverDidShowNotification
object:nil];
[notificationCenter
addObserver:self
selector:@selector(popoverDidClose:)
name:NSPopoverDidCloseNotification
object:nil];
}
// Set up the command updater for when there are no windows open
[self initMenuState];
// Initialize the Profile menu.
[self initProfileMenu];
}
- (void)unregisterEventHandlers {
NSAppleEventManager* em = [NSAppleEventManager sharedAppleEventManager];
[em removeEventHandlerForEventClass:kInternetEventClass
andEventID:kAEGetURL];
[em removeEventHandlerForEventClass:cloud_print::kAECloudPrintClass
andEventID:cloud_print::kAECloudPrintClass];
[em removeEventHandlerForEventClass:kAECloudPrintInstallClass
andEventID:kAECloudPrintInstallClass];
[em removeEventHandlerForEventClass:kAECloudPrintUninstallClass
andEventID:kAECloudPrintUninstallClass];
[em removeEventHandlerForEventClass:'WWW!'
andEventID:'OURL'];
[[NSNotificationCenter defaultCenter] removeObserver:self];
}
// (NSApplicationDelegate protocol) This is the Apple-approved place to override
// the default handlers.
- (void)applicationWillFinishLaunching:(NSNotification*)notification {
// Nothing here right now.
}
- (BOOL)tryToTerminateApplication:(NSApplication*)app {
// Check for in-process downloads, and prompt the user if they really want
// to quit (and thus cancel downloads). Only check if we're not already
// shutting down, else the user might be prompted multiple times if the
// download isn't stopped before terminate is called again.
if (!browser_shutdown::IsTryingToQuit() &&
![self shouldQuitWithInProgressDownloads])
return NO;
// TODO(viettrungluu): Remove Apple Event handlers here? (It's safe to leave
// them in, but I'm not sure about UX; we'd also want to disable other things
// though.) http://crbug.com/40861
// Check if the user really wants to quit by employing the confirm-to-quit
// mechanism.
if (!browser_shutdown::IsTryingToQuit() &&
[self applicationShouldTerminate:app] != NSTerminateNow)
return NO;
size_t num_browsers = BrowserList::size();
// Initiate a shutdown (via browser::CloseAllBrowsers()) if we aren't
// already shutting down.
if (!browser_shutdown::IsTryingToQuit()) {
content::NotificationService::current()->Notify(
content::NOTIFICATION_CLOSE_ALL_BROWSERS_REQUEST,
content::NotificationService::AllSources(),
content::NotificationService::NoDetails());
browser::CloseAllBrowsers();
}
return num_browsers == 0 ? YES : NO;
}
- (void)stopTryingToTerminateApplication:(NSApplication*)app {
if (browser_shutdown::IsTryingToQuit()) {
// Reset the "trying to quit" state, so that closing all browser windows
// will no longer lead to termination.
browser_shutdown::SetTryingToQuit(false);
// TODO(viettrungluu): Were we to remove Apple Event handlers above, we
// would have to reinstall them here. http://crbug.com/40861
}
}
- (NSApplicationTerminateReply)applicationShouldTerminate:(NSApplication*)app {
// Check if the preference is turned on.
const PrefService* prefs = g_browser_process->local_state();
if (!prefs->GetBoolean(prefs::kConfirmToQuitEnabled)) {
confirm_quit::RecordHistogram(confirm_quit::kNoConfirm);
return NSTerminateNow;
}
// If the application is going to terminate as the result of a Cmd+Q
// invocation, use the special sauce to prevent accidental quitting.
// http://dev.chromium.org/developers/design-documents/confirm-to-quit-experiment
// This logic is only for keyboard-initiated quits.
if (![ConfirmQuitPanelController eventTriggersFeature:[app currentEvent]])
return NSTerminateNow;
return [[ConfirmQuitPanelController sharedController]
runModalLoopForApplication:app];
}
// Called when the app is shutting down. Clean-up as appropriate.
- (void)applicationWillTerminate:(NSNotification*)aNotification {
// There better be no browser windows left at this point.
CHECK_EQ(0u, BrowserList::size());
// Tell BrowserList not to keep the browser process alive. Once all the
// browsers get dealloc'd, it will stop the RunLoop and fall back into main().
browser::EndKeepAlive();
[self unregisterEventHandlers];
}
- (void)didEndMainMessageLoop {
DCHECK_EQ(0u, browser::GetBrowserCount([self lastProfile]));
if (!browser::GetBrowserCount([self lastProfile])) {
// As we're shutting down, we need to nuke the TabRestoreService, which
// will start the shutdown of the NavigationControllers and allow for
// proper shutdown. If we don't do this, Chrome won't shut down cleanly,
// and may end up crashing when some thread tries to use the IO thread (or
// another thread) that is no longer valid.
TabRestoreServiceFactory::ResetForProfile([self lastProfile]);
}
}
// If the window has a tab controller, make "close window" be cmd-shift-w,
// otherwise leave it as the normal cmd-w. Capitalization of the key equivalent
// affects whether the shift modifier is used.
- (void)adjustCloseWindowMenuItemKeyEquivalent:(BOOL)enableCloseTabShortcut {
[closeWindowMenuItem_ setKeyEquivalent:(enableCloseTabShortcut ? @"W" :
@"w")];
[closeWindowMenuItem_ setKeyEquivalentModifierMask:NSCommandKeyMask];
}
// If the window has a tab controller, make "close tab" take over cmd-w,
// otherwise it shouldn't have any key-equivalent because it should be disabled.
- (void)adjustCloseTabMenuItemKeyEquivalent:(BOOL)enableCloseTabShortcut {
if (enableCloseTabShortcut) {
[closeTabMenuItem_ setKeyEquivalent:@"w"];
[closeTabMenuItem_ setKeyEquivalentModifierMask:NSCommandKeyMask];
} else {
[closeTabMenuItem_ setKeyEquivalent:@""];
[closeTabMenuItem_ setKeyEquivalentModifierMask:0];
}
}
// Explicitly remove any command-key equivalents from the close tab/window
// menus so that nothing can go haywire if we get a user action during pending
// updates.
- (void)clearCloseMenuItemKeyEquivalents {
[closeTabMenuItem_ setKeyEquivalent:@""];
[closeTabMenuItem_ setKeyEquivalentModifierMask:0];
[closeWindowMenuItem_ setKeyEquivalent:@""];
[closeWindowMenuItem_ setKeyEquivalentModifierMask:0];
}
// See if the focused window window has tabs, and adjust the key equivalents for
// Close Tab/Close Window accordingly.
- (void)fixCloseMenuItemKeyEquivalents {
fileMenuUpdatePending_ = NO;
NSWindow* window = [NSApp keyWindow];
NSWindow* mainWindow = [NSApp mainWindow];
if (!window || ([window parentWindow] == mainWindow)) {
// If the key window is a child of the main window (e.g. a bubble), the main
// window should be the one that handles the close menu item action.
// Also, there might be a small amount of time where there is no key window;
// in that case as well, just use our main browser window if there is one.
// You might think that we should just always use the main window, but the
// "About Chrome" window serves as a counterexample.
window = mainWindow;
}
BOOL hasTabs =
[[window windowController] isKindOfClass:[TabWindowController class]];
BOOL enableCloseTabShortcut = hasTabs && !hasPopover_;
[self adjustCloseWindowMenuItemKeyEquivalent:enableCloseTabShortcut];
[self adjustCloseTabMenuItemKeyEquivalent:enableCloseTabShortcut];
}
// Fix up the "close tab/close window" command-key equivalents. We do this
// after a delay to ensure that window layer state has been set by the time
// we do the enabling. This should only be called on the main thread, code that
// calls this (even as a side-effect) from other threads needs to be fixed.
- (void)delayedFixCloseMenuItemKeyEquivalents {
DCHECK([NSThread isMainThread]);
if (!fileMenuUpdatePending_) {
// The OS prefers keypresses to timers, so it's possible that a cmd-w
// can sneak in before this timer fires. In order to prevent that from
// having any bad consequences, just clear the keys combos altogether. They
// will be reset when the timer eventually fires.
if ([NSThread isMainThread]) {
fileMenuUpdatePending_ = YES;
[self clearCloseMenuItemKeyEquivalents];
[self performSelector:@selector(fixCloseMenuItemKeyEquivalents)
withObject:nil
afterDelay:0];
} else {
// This shouldn't be happening, but if it does, force it to the main
// thread to avoid dropping the update. Don't mess with
// |fileMenuUpdatePending_| as it's not expected to be threadsafe and
// there could be a race between the selector finishing and setting the
// flag.
[self
performSelectorOnMainThread:@selector(fixCloseMenuItemKeyEquivalents)
withObject:nil
waitUntilDone:NO];
}
}
}
// Called when we get a notification about the window layering changing to
// update the UI based on the new main window.
- (void)windowLayeringDidChange:(NSNotification*)notify {
[self delayedFixCloseMenuItemKeyEquivalents];
if ([notify name] == NSWindowDidResignKeyNotification) {
// If a window is closed, this notification is fired but |[NSApp keyWindow]|
// returns nil regardless of whether any suitable candidates for the key
// window remain. It seems that the new key window for the app is not set
// until after this notification is fired, so a check is performed after the
// run loop is allowed to spin.
[self performSelector:@selector(checkForAnyKeyWindows)
withObject:nil
afterDelay:0.0];
}
// If the window changed to a new BrowserWindowController, update the profile.
id windowController = [[notify object] windowController];
if ([notify name] == NSWindowDidBecomeMainNotification &&
[windowController isKindOfClass:[BrowserWindowController class]]) {
// If the profile is incognito, use the original profile.
Profile* newProfile = [windowController profile]->GetOriginalProfile();
[self windowChangedToProfile:newProfile];
} else if (BrowserList::empty()) {
[self windowChangedToProfile:
g_browser_process->profile_manager()->GetLastUsedProfile()];
}
}
// Called on Lion and later when a popover (e.g. dictionary) is shown.
- (void)popoverDidShow:(NSNotification*)notify {
hasPopover_ = YES;
[self fixCloseMenuItemKeyEquivalents];
}
// Called on Lion and later when a popover (e.g. dictionary) is closed.
- (void)popoverDidClose:(NSNotification*)notify {
hasPopover_ = NO;
[self fixCloseMenuItemKeyEquivalents];
}
// Called when the user has changed browser windows, meaning the backing profile
// may have changed. This can cause a rebuild of the user-data menus. This is a
// no-op if the new profile is the same as the current one. This will always be
// the original profile and never incognito.
- (void)windowChangedToProfile:(Profile*)profile {
if (lastProfile_ == profile)
return;
// Before tearing down the menu controller bridges, return the Cocoa menus to
// their initial state.
if (bookmarkMenuBridge_.get())
bookmarkMenuBridge_->ResetMenu();
if (historyMenuBridge_.get())
historyMenuBridge_->ResetMenu();
// Rebuild the menus with the new profile.
lastProfile_ = profile;
bookmarkMenuBridge_.reset(new BookmarkMenuBridge(lastProfile_,
[[[NSApp mainMenu] itemWithTag:IDC_BOOKMARKS_MENU] submenu]));
// No need to |BuildMenu| here. It is done lazily upon menu access.
historyMenuBridge_.reset(new HistoryMenuBridge(lastProfile_));
historyMenuBridge_->BuildMenu();
}
- (void)checkForAnyKeyWindows {
if ([NSApp keyWindow])
return;
content::NotificationService::current()->Notify(
content::NOTIFICATION_NO_KEY_WINDOW,
content::NotificationService::AllSources(),
content::NotificationService::NoDetails());
}
// If the auto-update interval is not set, make it 5 hours.
// This code is specific to Mac Chrome Dev Channel.
// Placed here for 2 reasons:
// 1) Same spot as other Pref stuff
// 2) Try and be friendly by keeping this after app launch
// TODO(jrg): remove once we go Beta.
- (void)setUpdateCheckInterval {
#if defined(GOOGLE_CHROME_BUILD)
CFStringRef app = (CFStringRef)@"com.google.Keystone.Agent";
CFStringRef checkInterval = (CFStringRef)@"checkInterval";
CFPropertyListRef plist = CFPreferencesCopyAppValue(checkInterval, app);
if (!plist) {
const float fiveHoursInSeconds = 5.0 * 60.0 * 60.0;
NSNumber* value = [NSNumber numberWithFloat:fiveHoursInSeconds];
CFPreferencesSetAppValue(checkInterval, value, app);
CFPreferencesAppSynchronize(app);
}
#endif
}
// This is called after profiles have been loaded and preferences registered.
// It is safe to access the default profile here.
- (void)applicationDidFinishLaunching:(NSNotification*)notify {
// Notify BrowserList to keep the application running so it doesn't go away
// when all the browser windows get closed.
browser::StartKeepAlive();
[self setUpdateCheckInterval];
// Build up the encoding menu, the order of the items differs based on the
// current locale (see http://crbug.com/7647 for details).
// We need a valid g_browser_process to get the profile which is why we can't
// call this from awakeFromNib.
NSMenu* viewMenu = [[[NSApp mainMenu] itemWithTag:IDC_VIEW_MENU] submenu];
NSMenuItem* encodingMenuItem = [viewMenu itemWithTag:IDC_ENCODING_MENU];
NSMenu* encodingMenu = [encodingMenuItem submenu];
EncodingMenuControllerDelegate::BuildEncodingMenu([self lastProfile],
encodingMenu);
// Since Chrome is localized to more languages than the OS, tell Cocoa which
// menu is the Help so it can add the search item to it.
if (helpMenu_ && [NSApp respondsToSelector:@selector(setHelpMenu:)])
[NSApp setHelpMenu:helpMenu_];
// Record the path to the (browser) app bundle; this is used by the app mode
// shim.
RecordLastRunAppBundlePath();
// Makes "Services" menu items available.
[self registerServicesMenuTypesTo:[notify object]];
startupComplete_ = YES;
// TODO(viettrungluu): This is very temporary, since this should be done "in"
// |BrowserMain()|, i.e., this list of startup URLs should be appended to the
// (probably-empty) list of URLs from the command line.
if (startupUrls_.size()) {
[self openUrls:startupUrls_];
[self clearStartupUrls];
}
const CommandLine& parsed_command_line = *CommandLine::ForCurrentProcess();
if (!parsed_command_line.HasSwitch(switches::kEnableExposeForTabs)) {
[tabposeMenuItem_ setHidden:YES];
}
}
// This is called after profiles have been loaded and preferences registered.
// It is safe to access the default profile here.
- (void)applicationDidBecomeActive:(NSNotification*)notify {
content::NotificationService::current()->Notify(
content::NOTIFICATION_APP_ACTIVATED,
content::NotificationService::AllSources(),
content::NotificationService::NoDetails());
}
// Helper function for populating and displaying the in progress downloads at
// exit alert panel.
- (BOOL)userWillWaitForInProgressDownloads:(int)downloadCount {
NSString* titleText = nil;
NSString* explanationText = nil;
NSString* waitTitle = nil;
NSString* exitTitle = nil;
// Set the dialog text based on whether or not there are multiple downloads.
if (downloadCount == 1) {
// Dialog text: warning and explanation.
titleText = l10n_util::GetNSString(
IDS_SINGLE_DOWNLOAD_REMOVE_CONFIRM_TITLE);
explanationText = l10n_util::GetNSString(
IDS_SINGLE_DOWNLOAD_REMOVE_CONFIRM_EXPLANATION);
} else {
// Dialog text: warning and explanation.
titleText = l10n_util::GetNSStringF(
IDS_MULTIPLE_DOWNLOADS_REMOVE_CONFIRM_TITLE,
base::IntToString16(downloadCount));
explanationText = l10n_util::GetNSString(
IDS_MULTIPLE_DOWNLOADS_REMOVE_CONFIRM_EXPLANATION);
}
// Cancel download and exit button text.
exitTitle = l10n_util::GetNSString(
IDS_DOWNLOAD_REMOVE_CONFIRM_OK_BUTTON_LABEL);
// Wait for download button text.
waitTitle = l10n_util::GetNSString(
IDS_DOWNLOAD_REMOVE_CONFIRM_CANCEL_BUTTON_LABEL);
// 'waitButton' is the default choice.
int choice = NSRunAlertPanel(titleText, explanationText,
waitTitle, exitTitle, nil);
return choice == NSAlertDefaultReturn ? YES : NO;
}
// Check all profiles for in progress downloads, and if we find any, prompt the
// user to see if we should continue to exit (and thus cancel the downloads), or
// if we should wait.
- (BOOL)shouldQuitWithInProgressDownloads {
ProfileManager* profile_manager = g_browser_process->profile_manager();
if (!profile_manager)
return YES;
std::vector<Profile*> profiles(profile_manager->GetLoadedProfiles());
for (size_t i = 0; i < profiles.size(); ++i) {
DownloadService* download_service =
DownloadServiceFactory::GetForProfile(profiles[i]);
DownloadManager* download_manager =
(download_service->HasCreatedDownloadManager() ?
BrowserContext::GetDownloadManager(profiles[i]) : NULL);
if (download_manager && download_manager->InProgressCount() > 0) {
int downloadCount = download_manager->InProgressCount();
if ([self userWillWaitForInProgressDownloads:downloadCount]) {
// Create a new browser window (if necessary) and navigate to the
// downloads page if the user chooses to wait.
Browser* browser = browser::FindBrowserWithProfile(profiles[i]);
if (!browser) {
browser = Browser::Create(profiles[i]);
browser->window()->Show();
}
DCHECK(browser);
chrome::ShowDownloads(browser);
return NO;
}
// User wants to exit.
return YES;
}
}
// No profiles or active downloads found, okay to exit.
return YES;
}
// Called to determine if we should enable the "restore tab" menu item.
// Checks with the TabRestoreService to see if there's anything there to
// restore and returns YES if so.
- (BOOL)canRestoreTab {
TabRestoreService* service =
TabRestoreServiceFactory::GetForProfile([self lastProfile]);
return service && !service->entries().empty();
}
// Returns true if there is not a modal window (either window- or application-
// modal) blocking the active browser. Note that tab modal dialogs (HTTP auth
// sheets) will not count as blocking the browser. But things like open/save
// dialogs that are window modal will block the browser.
- (BOOL)keyWindowIsNotModal {
Browser* browser = browser::GetLastActiveBrowser();
return [NSApp modalWindow] == nil && (!browser ||
![[browser->window()->GetNativeWindow() attachedSheet]
isKindOfClass:[NSWindow class]]);
}
// Called to validate menu items when there are no key windows. All the
// items we care about have been set with the |commandDispatch:| action and
// a target of FirstResponder in IB. If it's not one of those, let it
// continue up the responder chain to be handled elsewhere. We pull out the
// tag as the cross-platform constant to differentiate and dispatch the
// various commands.
- (BOOL)validateUserInterfaceItem:(id<NSValidatedUserInterfaceItem>)item {
SEL action = [item action];
BOOL enable = NO;
if (action == @selector(commandDispatch:)) {
NSInteger tag = [item tag];
if (menuState_->SupportsCommand(tag)) {
switch (tag) {
// The File Menu commands are not automatically disabled by Cocoa when a
// dialog sheet obscures the browser window, so we disable several of
// them here. We don't need to include IDC_CLOSE_WINDOW, because
// app_controller is only activated when there are no key windows (see
// function comment).
case IDC_RESTORE_TAB:
enable = [self keyWindowIsNotModal] && [self canRestoreTab];
break;
// Browser-level items that open in new tabs should not open if there's
// a window- or app-modal dialog.
case IDC_OPEN_FILE:
case IDC_NEW_TAB:
case IDC_SHOW_HISTORY:
case IDC_SHOW_BOOKMARK_MANAGER:
enable = [self keyWindowIsNotModal];
break;
// Browser-level items that open in new windows.
case IDC_NEW_WINDOW:
case IDC_TASK_MANAGER:
// Allow the user to open a new window if there's a window-modal
// dialog.
enable = [self keyWindowIsNotModal] || ([NSApp modalWindow] == nil);
break;
case IDC_SHOW_SYNC_SETUP: {
Profile* lastProfile = [self lastProfile];
// The profile may be NULL during shutdown -- see
// http://code.google.com/p/chromium/issues/detail?id=43048 .
//
// TODO(akalin,viettrungluu): Figure out whether this method
// can be prevented from being called if lastProfile is
// NULL.
if (!lastProfile) {
LOG(WARNING)
<< "NULL lastProfile detected -- not doing anything";
break;
}
enable = lastProfile->IsSyncAccessible() &&
[self keyWindowIsNotModal];
sync_ui_util::UpdateSyncItem(item, enable, lastProfile);
break;
}
case IDC_FEEDBACK:
enable = NO;
break;
default:
enable = menuState_->IsCommandEnabled(tag) ?
[self keyWindowIsNotModal] : NO;
}
}
} else if (action == @selector(terminate:)) {
enable = YES;
} else if (action == @selector(showPreferences:)) {
enable = YES;
} else if (action == @selector(orderFrontStandardAboutPanel:)) {
enable = YES;
} else if (action == @selector(commandFromDock:)) {
enable = YES;
} else if (action == @selector(toggleConfirmToQuit:)) {
[self updateConfirmToQuitPrefMenuItem:static_cast<NSMenuItem*>(item)];
enable = YES;
}
return enable;
}
// Called when the user picks a menu item when there are no key windows, or when
// there is no foreground browser window. Calls through to the browser object to
// execute the command. This assumes that the command is supported and doesn't
// check, otherwise it should have been disabled in the UI in
// |-validateUserInterfaceItem:|.
- (void)commandDispatch:(id)sender {
Profile* lastProfile = [self lastProfile];
// Handle the case where we're dispatching a command from a sender that's in a
// browser window. This means that the command came from a background window
// and is getting here because the foreground window is not a browser window.
if ([sender respondsToSelector:@selector(window)]) {
id delegate = [[sender window] windowController];
if ([delegate isKindOfClass:[BrowserWindowController class]]) {
[delegate commandDispatch:sender];
return;
}
}
NSInteger tag = [sender tag];
switch (tag) {
case IDC_NEW_TAB:
// Create a new tab in an existing browser window (which we activate) if
// possible.
if (Browser* browser = ActivateBrowser(lastProfile)) {
chrome::ExecuteCommand(browser, IDC_NEW_TAB);
break;
}
// Else fall through to create new window.
case IDC_NEW_WINDOW:
CreateBrowser(lastProfile);
break;
case IDC_FOCUS_LOCATION:
chrome::ExecuteCommand(ActivateOrCreateBrowser(lastProfile),
IDC_FOCUS_LOCATION);
break;
case IDC_FOCUS_SEARCH:
chrome::ExecuteCommand(ActivateOrCreateBrowser(lastProfile),
IDC_FOCUS_SEARCH);
break;
case IDC_NEW_INCOGNITO_WINDOW:
CreateBrowser(lastProfile->GetOffTheRecordProfile());
break;
case IDC_RESTORE_TAB:
chrome::OpenWindowWithRestoredTabs(lastProfile);
break;
case IDC_OPEN_FILE:
chrome::ExecuteCommand(CreateBrowser(lastProfile), IDC_OPEN_FILE);
break;
case IDC_CLEAR_BROWSING_DATA: {
// There may not be a browser open, so use the default profile.
if (Browser* browser = ActivateBrowser(lastProfile)) {
chrome::ShowClearBrowsingDataDialog(browser);
} else {
chrome::OpenClearBrowsingDataDialogWindow(lastProfile);
}
break;
}
case IDC_IMPORT_SETTINGS: {
if (Browser* browser = ActivateBrowser(lastProfile)) {
chrome::ShowImportDialog(browser);
} else {
chrome::OpenImportSettingsDialogWindow(lastProfile);
}
break;
}
case IDC_SHOW_BOOKMARK_MANAGER:
content::RecordAction(UserMetricsAction("ShowBookmarkManager"));
if (Browser* browser = ActivateBrowser(lastProfile)) {
chrome::ShowBookmarkManager(browser);
} else {
// No browser window, so create one for the bookmark manager tab.
chrome::OpenBookmarkManagerWindow(lastProfile);
}
break;
case IDC_SHOW_HISTORY:
if (Browser* browser = ActivateBrowser(lastProfile))
chrome::ShowHistory(browser);
else
chrome::OpenHistoryWindow(lastProfile);
break;
case IDC_SHOW_DOWNLOADS:
if (Browser* browser = ActivateBrowser(lastProfile))
chrome::ShowDownloads(browser);
else
chrome::OpenDownloadsWindow(lastProfile);
break;
case IDC_MANAGE_EXTENSIONS:
if (Browser* browser = ActivateBrowser(lastProfile))
chrome::ShowExtensions(browser);
else
chrome::OpenExtensionsWindow(lastProfile);
break;
case IDC_HELP_PAGE_VIA_MENU:
if (Browser* browser = ActivateBrowser(lastProfile))
chrome::ShowHelp(browser, chrome::HELP_SOURCE_MENU);
else
chrome::OpenHelpWindow(lastProfile, chrome::HELP_SOURCE_MENU);
break;
case IDC_SHOW_SYNC_SETUP:
if (Browser* browser = ActivateBrowser(lastProfile))
chrome::ShowSyncSetup(browser, SyncPromoUI::SOURCE_MENU);
else
chrome::OpenSyncSetupWindow(lastProfile, SyncPromoUI::SOURCE_MENU);
break;
case IDC_TASK_MANAGER:
content::RecordAction(UserMetricsAction("TaskManager"));
TaskManagerMac::Show(false);
break;
case IDC_OPTIONS:
[self showPreferences:sender];
break;
default:
// Background Applications use dynamic values that must be less than the
// smallest value among the predefined IDC_* labels.
if ([sender tag] < IDC_MinimumLabelValue)
[self executeApplication:sender];
break;
}
}
// Run a (background) application in a new tab.
- (void)executeApplication:(id)sender {
NSInteger tag = [sender tag];
Profile* profile = [self lastProfile];
DCHECK(profile);
BackgroundApplicationListModel applications(profile);
DCHECK(tag >= 0 &&
tag < static_cast<int>(applications.size()));
const extensions::Extension* extension = applications.GetExtension(tag);
BackgroundModeManager::LaunchBackgroundApplication(profile, extension);
}
// Same as |-commandDispatch:|, but executes commands using a disposition
// determined by the key flags. This will get called in the case where the
// frontmost window is not a browser window, and the user has command-clicked
// a button in a background browser window whose action is
// |-commandDispatchUsingKeyModifiers:|
- (void)commandDispatchUsingKeyModifiers:(id)sender {
DCHECK(sender);
if ([sender respondsToSelector:@selector(window)]) {
id delegate = [[sender window] windowController];
if ([delegate isKindOfClass:[BrowserWindowController class]]) {
[delegate commandDispatchUsingKeyModifiers:sender];
}
}
}
// NSApplication delegate method called when someone clicks on the
// dock icon and there are no open windows. To match standard mac
// behavior, we should open a new window.
- (BOOL)applicationShouldHandleReopen:(NSApplication*)theApplication
hasVisibleWindows:(BOOL)flag {
// If the browser is currently trying to quit, don't do anything and return NO
// to prevent AppKit from doing anything.
// TODO(rohitrao): Remove this code when http://crbug.com/40861 is resolved.
if (browser_shutdown::IsTryingToQuit())
return NO;
// Don't do anything if there are visible tabbed or popup windows. This will
// cause AppKit to unminimize the most recently minimized window. If the
// visible windows are panels or notifications, we still need to open a new
// window.
if (flag) {
for (BrowserList::const_iterator iter = BrowserList::begin();
iter != BrowserList::end(); ++iter) {
Browser* browser = *iter;
if (browser->is_type_tabbed() || browser->is_type_popup())
return YES;
}
}
// If launched as a hidden login item (due to installation of a persistent app
// or by the user, for example in System Preferences->Accounts->Login Items),
// allow session to be restored first time the user clicks on a Dock icon.
// Normally, it'd just open a new empty page.
{
static BOOL doneOnce = NO;
if (!doneOnce) {
doneOnce = YES;
if (base::mac::WasLaunchedAsHiddenLoginItem()) {
SessionService* sessionService =
SessionServiceFactory::GetForProfile([self lastProfile]);
if (sessionService &&
sessionService->RestoreIfNecessary(std::vector<GURL>()))
return NO;
}
}
}
// Platform apps don't use browser windows so don't do anything if there are
// visible windows.
const CommandLine& command_line = *CommandLine::ForCurrentProcess();
if (flag && command_line.HasSwitch(switches::kAppId))
return YES;
// Otherwise open a new window.
{
AutoReset<bool> auto_reset_in_run(&g_is_opening_new_window, true);