2014-10-31 18:17:05 +00:00
|
|
|
// Copyright (c) 2013 GitHub, Inc.
|
2014-04-25 09:49:37 +00:00
|
|
|
// Use of this source code is governed by the MIT license that can be
|
2013-05-02 15:43:23 +00:00
|
|
|
// found in the LICENSE file.
|
|
|
|
|
2019-06-19 20:46:59 +00:00
|
|
|
#include "shell/browser/browser.h"
|
2013-05-02 15:43:23 +00:00
|
|
|
|
2020-05-21 15:53:44 +00:00
|
|
|
#include <memory>
|
2019-05-02 12:05:37 +00:00
|
|
|
#include <string>
|
|
|
|
#include <utility>
|
|
|
|
|
2016-03-21 18:24:25 +00:00
|
|
|
#include "base/mac/bundle_locations.h"
|
2015-04-14 07:55:41 +00:00
|
|
|
#include "base/mac/foundation_util.h"
|
2016-07-06 18:43:44 +00:00
|
|
|
#include "base/mac/mac_util.h"
|
2019-02-21 17:13:43 +00:00
|
|
|
#include "base/mac/scoped_cftyperef.h"
|
2016-07-01 08:39:01 +00:00
|
|
|
#include "base/strings/string_number_conversions.h"
|
2016-07-02 01:36:11 +00:00
|
|
|
#include "base/strings/sys_string_conversions.h"
|
2016-05-23 15:49:46 +00:00
|
|
|
#include "net/base/mac/url_conversions.h"
|
2019-06-19 20:46:59 +00:00
|
|
|
#include "shell/browser/mac/dict_util.h"
|
2020-02-04 20:19:40 +00:00
|
|
|
#include "shell/browser/mac/electron_application.h"
|
|
|
|
#include "shell/browser/mac/electron_application_delegate.h"
|
2019-06-19 20:46:59 +00:00
|
|
|
#include "shell/browser/native_window.h"
|
|
|
|
#include "shell/browser/window_list.h"
|
|
|
|
#include "shell/common/application_info.h"
|
2020-06-30 19:22:30 +00:00
|
|
|
#include "shell/common/gin_converters/image_converter.h"
|
2019-10-24 05:47:58 +00:00
|
|
|
#include "shell/common/gin_helper/arguments.h"
|
2020-03-11 16:07:01 +00:00
|
|
|
#include "shell/common/gin_helper/dictionary.h"
|
|
|
|
#include "shell/common/gin_helper/error_thrower.h"
|
2019-11-01 06:10:32 +00:00
|
|
|
#include "shell/common/gin_helper/promise.h"
|
2019-06-19 20:46:59 +00:00
|
|
|
#include "shell/common/platform_util.h"
|
2018-03-06 07:12:10 +00:00
|
|
|
#include "ui/gfx/image/image.h"
|
2016-05-23 15:49:46 +00:00
|
|
|
#include "url/gurl.h"
|
2013-05-02 15:43:23 +00:00
|
|
|
|
2019-06-19 21:23:04 +00:00
|
|
|
namespace electron {
|
2013-05-02 15:43:23 +00:00
|
|
|
|
2020-06-30 19:22:30 +00:00
|
|
|
namespace {
|
|
|
|
|
|
|
|
NSString* GetAppPathForProtocol(const GURL& url) {
|
|
|
|
NSURL* ns_url = [NSURL
|
|
|
|
URLWithString:base::SysUTF8ToNSString(url.possibly_invalid_spec())];
|
|
|
|
base::ScopedCFTypeRef<CFErrorRef> out_err;
|
|
|
|
|
|
|
|
base::ScopedCFTypeRef<CFURLRef> openingApp(LSCopyDefaultApplicationURLForURL(
|
|
|
|
(CFURLRef)ns_url, kLSRolesAll, out_err.InitializeInto()));
|
|
|
|
|
|
|
|
if (out_err) {
|
|
|
|
// likely kLSApplicationNotFoundErr
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
NSString* app_path = [base::mac::CFToNSCast(openingApp.get()) path];
|
|
|
|
return app_path;
|
|
|
|
}
|
|
|
|
|
|
|
|
gfx::Image GetApplicationIconForProtocol(NSString* _Nonnull app_path) {
|
|
|
|
NSImage* image = [[NSWorkspace sharedWorkspace] iconForFile:app_path];
|
|
|
|
gfx::Image icon(image);
|
|
|
|
return icon;
|
|
|
|
}
|
|
|
|
|
|
|
|
base::string16 GetAppDisplayNameForProtocol(NSString* app_path) {
|
|
|
|
NSString* app_display_name =
|
|
|
|
[[NSFileManager defaultManager] displayNameAtPath:app_path];
|
|
|
|
return base::SysNSStringToUTF16(app_display_name);
|
|
|
|
}
|
|
|
|
|
|
|
|
} // namespace
|
|
|
|
|
|
|
|
v8::Local<v8::Promise> Browser::GetApplicationInfoForProtocol(
|
|
|
|
v8::Isolate* isolate,
|
|
|
|
const GURL& url) {
|
|
|
|
gin_helper::Promise<gin_helper::Dictionary> promise(isolate);
|
|
|
|
v8::Local<v8::Promise> handle = promise.GetHandle();
|
|
|
|
gin_helper::Dictionary dict = gin::Dictionary::CreateEmpty(isolate);
|
|
|
|
|
|
|
|
NSString* ns_app_path = GetAppPathForProtocol(url);
|
|
|
|
|
|
|
|
if (!ns_app_path) {
|
|
|
|
promise.RejectWithErrorMessage(
|
|
|
|
"Unable to retrieve installation path to app");
|
|
|
|
return handle;
|
|
|
|
}
|
|
|
|
|
|
|
|
base::string16 app_path = base::SysNSStringToUTF16(ns_app_path);
|
|
|
|
base::string16 app_display_name = GetAppDisplayNameForProtocol(ns_app_path);
|
|
|
|
gfx::Image app_icon = GetApplicationIconForProtocol(ns_app_path);
|
|
|
|
|
|
|
|
dict.Set("name", app_display_name);
|
|
|
|
dict.Set("path", app_path);
|
|
|
|
dict.Set("icon", app_icon);
|
|
|
|
|
|
|
|
promise.Resolve(dict);
|
|
|
|
return handle;
|
|
|
|
}
|
|
|
|
|
2018-02-05 07:13:35 +00:00
|
|
|
void Browser::SetShutdownHandler(base::Callback<bool()> handler) {
|
2020-02-21 19:05:03 +00:00
|
|
|
[[AtomApplication sharedApplication] setShutdownHandler:std::move(handler)];
|
2018-02-05 07:13:35 +00:00
|
|
|
}
|
|
|
|
|
2020-07-28 23:43:43 +00:00
|
|
|
void Browser::Focus(gin::Arguments* args) {
|
2020-03-11 16:07:01 +00:00
|
|
|
gin_helper::Dictionary opts;
|
|
|
|
bool steal_focus = false;
|
|
|
|
|
|
|
|
if (args->GetNext(&opts)) {
|
|
|
|
gin_helper::ErrorThrower thrower(args->isolate());
|
|
|
|
if (!opts.Get("steal", &steal_focus)) {
|
|
|
|
thrower.ThrowError(
|
|
|
|
"Expected options object to contain a 'steal' boolean property");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
[[AtomApplication sharedApplication] activateIgnoringOtherApps:steal_focus];
|
2013-05-30 11:24:47 +00:00
|
|
|
}
|
|
|
|
|
2016-01-29 11:30:19 +00:00
|
|
|
void Browser::Hide() {
|
2020-02-21 19:05:03 +00:00
|
|
|
[[AtomApplication sharedApplication] hide:nil];
|
2016-01-29 11:30:19 +00:00
|
|
|
}
|
|
|
|
|
2016-01-30 20:40:32 +00:00
|
|
|
void Browser::Show() {
|
2020-02-21 19:05:03 +00:00
|
|
|
[[AtomApplication sharedApplication] unhide:nil];
|
2016-01-30 20:40:32 +00:00
|
|
|
}
|
|
|
|
|
2014-11-17 05:05:06 +00:00
|
|
|
void Browser::AddRecentDocument(const base::FilePath& path) {
|
2015-12-15 09:17:24 +00:00
|
|
|
NSString* path_string = base::mac::FilePathToNSString(path);
|
|
|
|
if (!path_string)
|
|
|
|
return;
|
|
|
|
NSURL* u = [NSURL fileURLWithPath:path_string];
|
|
|
|
if (!u)
|
|
|
|
return;
|
2014-11-17 05:05:06 +00:00
|
|
|
[[NSDocumentController sharedDocumentController] noteNewRecentDocumentURL:u];
|
|
|
|
}
|
|
|
|
|
2014-11-17 08:13:47 +00:00
|
|
|
void Browser::ClearRecentDocuments() {
|
2015-12-30 00:35:54 +00:00
|
|
|
[[NSDocumentController sharedDocumentController] clearRecentDocuments:nil];
|
2014-11-17 08:13:47 +00:00
|
|
|
}
|
|
|
|
|
2016-08-16 05:54:30 +00:00
|
|
|
bool Browser::RemoveAsDefaultProtocolClient(const std::string& protocol,
|
2020-07-28 23:43:43 +00:00
|
|
|
gin::Arguments* args) {
|
2016-05-07 18:07:58 +00:00
|
|
|
NSString* identifier = [base::mac::MainBundle() bundleIdentifier];
|
|
|
|
if (!identifier)
|
|
|
|
return false;
|
|
|
|
|
2016-08-16 07:40:44 +00:00
|
|
|
if (!Browser::IsDefaultProtocolClient(protocol, args))
|
2016-05-08 17:50:17 +00:00
|
|
|
return false;
|
|
|
|
|
2016-05-07 18:07:58 +00:00
|
|
|
NSString* protocol_ns = [NSString stringWithUTF8String:protocol.c_str()];
|
|
|
|
CFStringRef protocol_cf = base::mac::NSToCFCast(protocol_ns);
|
|
|
|
CFArrayRef bundleList = LSCopyAllHandlersForURLScheme(protocol_cf);
|
|
|
|
if (!bundleList) {
|
|
|
|
return false;
|
|
|
|
}
|
2016-06-18 13:26:26 +00:00
|
|
|
// On macOS, we can't query the default, but the handlers list seems to put
|
2016-05-07 18:07:58 +00:00
|
|
|
// Apple's defaults first, so we'll use the first option that isn't our bundle
|
|
|
|
CFStringRef other = nil;
|
2017-03-30 20:56:21 +00:00
|
|
|
for (CFIndex i = 0; i < CFArrayGetCount(bundleList); ++i) {
|
2018-04-20 18:47:04 +00:00
|
|
|
other =
|
|
|
|
base::mac::CFCast<CFStringRef>(CFArrayGetValueAtIndex(bundleList, i));
|
|
|
|
if (![identifier isEqualToString:(__bridge NSString*)other]) {
|
2016-05-07 18:07:58 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-06-20 03:16:37 +00:00
|
|
|
// No other app was found set it to none instead of setting it back to itself.
|
|
|
|
if ([identifier isEqualToString:(__bridge NSString*)other]) {
|
|
|
|
other = base::mac::NSToCFCast(@"None");
|
|
|
|
}
|
|
|
|
|
2016-05-07 18:07:58 +00:00
|
|
|
OSStatus return_code = LSSetDefaultHandlerForURLScheme(protocol_cf, other);
|
|
|
|
return return_code == noErr;
|
2016-03-24 17:55:09 +00:00
|
|
|
}
|
|
|
|
|
2016-08-16 05:54:30 +00:00
|
|
|
bool Browser::SetAsDefaultProtocolClient(const std::string& protocol,
|
2020-07-28 23:43:43 +00:00
|
|
|
gin::Arguments* args) {
|
2016-03-21 18:24:25 +00:00
|
|
|
if (protocol.empty())
|
|
|
|
return false;
|
|
|
|
|
|
|
|
NSString* identifier = [base::mac::MainBundle() bundleIdentifier];
|
|
|
|
if (!identifier)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
NSString* protocol_ns = [NSString stringWithUTF8String:protocol.c_str()];
|
2018-04-20 18:47:04 +00:00
|
|
|
OSStatus return_code = LSSetDefaultHandlerForURLScheme(
|
|
|
|
base::mac::NSToCFCast(protocol_ns), base::mac::NSToCFCast(identifier));
|
2016-03-21 18:24:25 +00:00
|
|
|
return return_code == noErr;
|
|
|
|
}
|
|
|
|
|
2016-08-16 05:54:30 +00:00
|
|
|
bool Browser::IsDefaultProtocolClient(const std::string& protocol,
|
2020-07-28 23:43:43 +00:00
|
|
|
gin::Arguments* args) {
|
2016-04-25 05:17:01 +00:00
|
|
|
if (protocol.empty())
|
|
|
|
return false;
|
|
|
|
|
|
|
|
NSString* identifier = [base::mac::MainBundle() bundleIdentifier];
|
|
|
|
if (!identifier)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
NSString* protocol_ns = [NSString stringWithUTF8String:protocol.c_str()];
|
2016-04-30 18:17:29 +00:00
|
|
|
|
2019-02-21 17:13:43 +00:00
|
|
|
base::ScopedCFTypeRef<CFStringRef> bundleId(
|
|
|
|
LSCopyDefaultHandlerForURLScheme(base::mac::NSToCFCast(protocol_ns)));
|
|
|
|
|
2016-04-25 05:17:01 +00:00
|
|
|
if (!bundleId)
|
|
|
|
return false;
|
|
|
|
|
2016-04-30 18:17:29 +00:00
|
|
|
// Ensure the comparison is case-insensitive
|
2016-04-25 05:17:01 +00:00
|
|
|
// as LS does not persist the case of the bundle id.
|
2019-02-21 17:13:43 +00:00
|
|
|
NSComparisonResult result =
|
|
|
|
[base::mac::CFToNSCast(bundleId) caseInsensitiveCompare:identifier];
|
2016-04-25 05:17:01 +00:00
|
|
|
return result == NSOrderedSame;
|
|
|
|
}
|
|
|
|
|
2019-11-07 01:50:33 +00:00
|
|
|
base::string16 Browser::GetApplicationNameForProtocol(const GURL& url) {
|
2020-06-30 19:22:30 +00:00
|
|
|
NSString* app_path = GetAppPathForProtocol(url);
|
|
|
|
if (!app_path) {
|
2019-11-07 01:50:33 +00:00
|
|
|
return base::string16();
|
|
|
|
}
|
2020-06-30 19:22:30 +00:00
|
|
|
base::string16 app_display_name = GetAppDisplayNameForProtocol(app_path);
|
|
|
|
return app_display_name;
|
2019-11-07 01:50:33 +00:00
|
|
|
}
|
|
|
|
|
2018-04-20 18:47:04 +00:00
|
|
|
void Browser::SetAppUserModelID(const base::string16& name) {}
|
2015-11-03 07:09:31 +00:00
|
|
|
|
2016-07-01 13:18:39 +00:00
|
|
|
bool Browser::SetBadgeCount(int count) {
|
2019-04-20 17:20:37 +00:00
|
|
|
DockSetBadgeText(count != 0 ? base::NumberToString(count) : "");
|
2016-07-02 01:36:11 +00:00
|
|
|
badge_count_ = count;
|
2016-07-01 13:18:39 +00:00
|
|
|
return true;
|
2016-07-01 08:39:01 +00:00
|
|
|
}
|
|
|
|
|
2016-05-23 15:49:46 +00:00
|
|
|
void Browser::SetUserActivity(const std::string& type,
|
2019-10-30 05:30:59 +00:00
|
|
|
base::DictionaryValue user_info,
|
2020-07-28 23:43:43 +00:00
|
|
|
gin::Arguments* args) {
|
2016-05-23 15:49:46 +00:00
|
|
|
std::string url_string;
|
|
|
|
args->GetNext(&url_string);
|
|
|
|
|
2020-02-21 19:05:03 +00:00
|
|
|
[[AtomApplication sharedApplication]
|
2016-05-05 07:38:47 +00:00
|
|
|
setCurrentActivity:base::SysUTF8ToNSString(type)
|
2016-05-23 15:49:46 +00:00
|
|
|
withUserInfo:DictionaryValueToNSDictionary(user_info)
|
|
|
|
withWebpageURL:net::NSURLWithGURL(GURL(url_string))];
|
2016-05-03 22:51:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
std::string Browser::GetCurrentActivityType() {
|
2019-02-25 17:21:57 +00:00
|
|
|
NSUserActivity* userActivity =
|
2020-02-21 19:05:03 +00:00
|
|
|
[[AtomApplication sharedApplication] getCurrentActivity];
|
2019-02-25 17:21:57 +00:00
|
|
|
return base::SysNSStringToUTF8(userActivity.activityType);
|
2016-04-30 00:35:07 +00:00
|
|
|
}
|
|
|
|
|
2017-06-26 19:14:44 +00:00
|
|
|
void Browser::InvalidateCurrentActivity() {
|
2020-02-21 19:05:03 +00:00
|
|
|
[[AtomApplication sharedApplication] invalidateCurrentActivity];
|
2017-06-26 19:14:44 +00:00
|
|
|
}
|
|
|
|
|
2019-06-07 05:16:03 +00:00
|
|
|
void Browser::ResignCurrentActivity() {
|
2020-02-21 19:05:03 +00:00
|
|
|
[[AtomApplication sharedApplication] resignCurrentActivity];
|
2019-06-07 05:16:03 +00:00
|
|
|
}
|
|
|
|
|
2017-06-26 19:14:44 +00:00
|
|
|
void Browser::UpdateCurrentActivity(const std::string& type,
|
2019-10-30 05:30:59 +00:00
|
|
|
base::DictionaryValue user_info) {
|
2020-02-21 19:05:03 +00:00
|
|
|
[[AtomApplication sharedApplication]
|
2017-06-26 19:14:44 +00:00
|
|
|
updateCurrentActivity:base::SysUTF8ToNSString(type)
|
|
|
|
withUserInfo:DictionaryValueToNSDictionary(user_info)];
|
|
|
|
}
|
|
|
|
|
|
|
|
bool Browser::WillContinueUserActivity(const std::string& type) {
|
|
|
|
bool prevent_default = false;
|
2017-09-14 07:12:34 +00:00
|
|
|
for (BrowserObserver& observer : observers_)
|
|
|
|
observer.OnWillContinueUserActivity(&prevent_default, type);
|
2017-06-26 19:14:44 +00:00
|
|
|
return prevent_default;
|
|
|
|
}
|
2017-09-14 07:12:34 +00:00
|
|
|
|
2017-06-26 19:14:44 +00:00
|
|
|
void Browser::DidFailToContinueUserActivity(const std::string& type,
|
|
|
|
const std::string& error) {
|
|
|
|
for (BrowserObserver& observer : observers_)
|
|
|
|
observer.OnDidFailToContinueUserActivity(type, error);
|
|
|
|
}
|
|
|
|
|
2016-05-23 15:49:46 +00:00
|
|
|
bool Browser::ContinueUserActivity(const std::string& type,
|
2019-10-30 05:30:59 +00:00
|
|
|
base::DictionaryValue user_info) {
|
2016-05-05 07:26:44 +00:00
|
|
|
bool prevent_default = false;
|
2017-01-24 03:34:39 +00:00
|
|
|
for (BrowserObserver& observer : observers_)
|
|
|
|
observer.OnContinueUserActivity(&prevent_default, type, user_info);
|
2016-05-05 07:26:44 +00:00
|
|
|
return prevent_default;
|
|
|
|
}
|
2017-09-14 07:12:34 +00:00
|
|
|
|
2017-06-26 19:14:44 +00:00
|
|
|
void Browser::UserActivityWasContinued(const std::string& type,
|
2019-10-30 05:30:59 +00:00
|
|
|
base::DictionaryValue user_info) {
|
2017-06-26 19:14:44 +00:00
|
|
|
for (BrowserObserver& observer : observers_)
|
|
|
|
observer.OnUserActivityWasContinued(type, user_info);
|
|
|
|
}
|
|
|
|
|
2017-08-09 15:09:47 +00:00
|
|
|
bool Browser::UpdateUserActivityState(const std::string& type,
|
2019-10-30 05:30:59 +00:00
|
|
|
base::DictionaryValue user_info) {
|
2017-08-09 15:09:47 +00:00
|
|
|
bool prevent_default = false;
|
2017-06-26 19:14:44 +00:00
|
|
|
for (BrowserObserver& observer : observers_)
|
2017-08-09 15:09:47 +00:00
|
|
|
observer.OnUpdateUserActivityState(&prevent_default, type, user_info);
|
|
|
|
return prevent_default;
|
2017-06-26 19:14:44 +00:00
|
|
|
}
|
2016-05-05 07:26:44 +00:00
|
|
|
|
2017-01-30 22:01:40 +00:00
|
|
|
Browser::LoginItemSettings Browser::GetLoginItemSettings(
|
2017-03-29 19:29:52 +00:00
|
|
|
const LoginItemSettings& options) {
|
2016-07-07 23:29:09 +00:00
|
|
|
LoginItemSettings settings;
|
2017-10-17 07:28:29 +00:00
|
|
|
#if defined(MAS_BUILD)
|
|
|
|
settings.open_at_login = platform_util::GetLoginItemEnabled();
|
|
|
|
#else
|
2018-04-20 18:47:04 +00:00
|
|
|
settings.open_at_login =
|
|
|
|
base::mac::CheckLoginItemStatus(&settings.open_as_hidden);
|
2016-07-07 23:29:09 +00:00
|
|
|
settings.restore_state = base::mac::WasLaunchedAsLoginItemRestoreState();
|
|
|
|
settings.opened_at_login = base::mac::WasLaunchedAsLoginOrResumeItem();
|
|
|
|
settings.opened_as_hidden = base::mac::WasLaunchedAsHiddenLoginItem();
|
2017-10-17 07:28:29 +00:00
|
|
|
#endif
|
2016-07-07 23:29:09 +00:00
|
|
|
return settings;
|
2016-07-06 20:26:16 +00:00
|
|
|
}
|
|
|
|
|
2019-07-15 21:36:23 +00:00
|
|
|
void RemoveFromLoginItems() {
|
2020-12-14 18:57:36 +00:00
|
|
|
#pragma clang diagnostic push // https://crbug.com/1154377
|
|
|
|
#pragma clang diagnostic ignored "-Wdeprecated-declarations"
|
2019-07-15 21:36:23 +00:00
|
|
|
// logic to find the login item copied from GetLoginItemForApp in
|
|
|
|
// base/mac/mac_util.mm
|
2018-10-12 22:19:27 +00:00
|
|
|
base::ScopedCFTypeRef<LSSharedFileListRef> login_items(
|
|
|
|
LSSharedFileListCreate(NULL, kLSSharedFileListSessionLoginItems, NULL));
|
|
|
|
if (!login_items.get()) {
|
|
|
|
LOG(ERROR) << "Couldn't get a Login Items list.";
|
2019-07-15 21:36:23 +00:00
|
|
|
return;
|
2018-10-12 22:19:27 +00:00
|
|
|
}
|
|
|
|
base::scoped_nsobject<NSArray> login_items_array(
|
|
|
|
base::mac::CFToNSCast(LSSharedFileListCopySnapshot(login_items, NULL)));
|
|
|
|
NSURL* url = [NSURL fileURLWithPath:[base::mac::MainBundle() bundlePath]];
|
|
|
|
for (NSUInteger i = 0; i < [login_items_array count]; ++i) {
|
|
|
|
LSSharedFileListItemRef item =
|
|
|
|
reinterpret_cast<LSSharedFileListItemRef>(login_items_array[i]);
|
2019-02-04 17:07:51 +00:00
|
|
|
base::ScopedCFTypeRef<CFErrorRef> error;
|
|
|
|
CFURLRef item_url_ref =
|
|
|
|
LSSharedFileListItemCopyResolvedURL(item, 0, error.InitializeInto());
|
|
|
|
if (!error && item_url_ref) {
|
2018-10-12 22:19:27 +00:00
|
|
|
base::ScopedCFTypeRef<CFURLRef> item_url(item_url_ref);
|
|
|
|
if (CFEqual(item_url, url)) {
|
2019-07-15 21:36:23 +00:00
|
|
|
LSSharedFileListItemRemove(login_items, item);
|
|
|
|
return;
|
2018-10-12 22:19:27 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2020-12-14 18:57:36 +00:00
|
|
|
#pragma clang diagnostic pop
|
2018-10-12 22:19:27 +00:00
|
|
|
}
|
|
|
|
|
2017-01-30 22:01:40 +00:00
|
|
|
void Browser::SetLoginItemSettings(LoginItemSettings settings) {
|
2017-10-17 07:28:29 +00:00
|
|
|
#if defined(MAS_BUILD)
|
2018-11-28 04:16:53 +00:00
|
|
|
if (!platform_util::SetLoginItemEnabled(settings.open_at_login)) {
|
|
|
|
LOG(ERROR) << "Unable to set login item enabled on sandboxed app.";
|
|
|
|
}
|
2017-10-17 07:28:29 +00:00
|
|
|
#else
|
2019-05-02 12:05:37 +00:00
|
|
|
if (settings.open_at_login) {
|
2016-07-07 23:29:09 +00:00
|
|
|
base::mac::AddToLoginItems(settings.open_as_hidden);
|
2019-05-02 12:05:37 +00:00
|
|
|
} else {
|
2018-10-12 22:19:27 +00:00
|
|
|
RemoveFromLoginItems();
|
|
|
|
}
|
2017-10-17 07:28:29 +00:00
|
|
|
#endif
|
2016-07-06 20:26:16 +00:00
|
|
|
}
|
|
|
|
|
2013-12-05 02:26:01 +00:00
|
|
|
std::string Browser::GetExecutableFileVersion() const {
|
2018-10-24 10:49:10 +00:00
|
|
|
return GetApplicationVersion();
|
2013-06-19 05:41:54 +00:00
|
|
|
}
|
|
|
|
|
2013-12-05 02:42:04 +00:00
|
|
|
std::string Browser::GetExecutableFileProductName() const {
|
2018-10-24 10:49:10 +00:00
|
|
|
return GetApplicationName();
|
2013-12-05 02:42:04 +00:00
|
|
|
}
|
|
|
|
|
2013-08-06 08:19:56 +00:00
|
|
|
int Browser::DockBounce(BounceType type) {
|
2020-02-21 19:05:03 +00:00
|
|
|
return [[AtomApplication sharedApplication]
|
2017-03-30 21:05:47 +00:00
|
|
|
requestUserAttention:static_cast<NSRequestUserAttentionType>(type)];
|
2013-08-06 08:19:56 +00:00
|
|
|
}
|
|
|
|
|
2016-01-23 13:59:05 +00:00
|
|
|
void Browser::DockCancelBounce(int request_id) {
|
2020-02-21 19:05:03 +00:00
|
|
|
[[AtomApplication sharedApplication] cancelUserAttentionRequest:request_id];
|
2013-08-06 08:19:56 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void Browser::DockSetBadgeText(const std::string& label) {
|
2020-02-21 19:05:03 +00:00
|
|
|
NSDockTile* tile = [[AtomApplication sharedApplication] dockTile];
|
2013-08-06 08:19:56 +00:00
|
|
|
[tile setBadgeLabel:base::SysUTF8ToNSString(label)];
|
|
|
|
}
|
|
|
|
|
2016-05-10 19:02:56 +00:00
|
|
|
void Browser::DockDownloadFinished(const std::string& filePath) {
|
|
|
|
[[NSDistributedNotificationCenter defaultCenter]
|
2018-04-20 18:47:04 +00:00
|
|
|
postNotificationName:@"com.apple.DownloadFileFinished"
|
|
|
|
object:base::SysUTF8ToNSString(filePath)];
|
2016-05-10 19:02:56 +00:00
|
|
|
}
|
|
|
|
|
2013-08-06 08:39:31 +00:00
|
|
|
std::string Browser::DockGetBadgeText() {
|
2020-02-21 19:05:03 +00:00
|
|
|
NSDockTile* tile = [[AtomApplication sharedApplication] dockTile];
|
2013-08-06 08:39:31 +00:00
|
|
|
return base::SysNSStringToUTF8([tile badgeLabel]);
|
|
|
|
}
|
|
|
|
|
2014-06-25 03:55:33 +00:00
|
|
|
void Browser::DockHide() {
|
2020-09-03 11:46:24 +00:00
|
|
|
// Transforming application state from UIElement to Foreground is an
|
|
|
|
// asyncronous operation, and unfortunately there is currently no way to know
|
|
|
|
// when it is finished.
|
|
|
|
// So if we call DockHide => DockShow => DockHide => DockShow in a very short
|
|
|
|
// time, we would triger a bug of macOS that, there would be multiple dock
|
|
|
|
// icons of the app left in system.
|
|
|
|
// To work around this, we make sure DockHide does nothing if it is called
|
|
|
|
// immediately after DockShow. After some experiments, 1 second seems to be
|
|
|
|
// a proper interval.
|
|
|
|
if (!last_dock_show_.is_null() &&
|
|
|
|
base::Time::Now() - last_dock_show_ < base::TimeDelta::FromSeconds(1)) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2018-04-17 22:41:47 +00:00
|
|
|
for (auto* const& window : WindowList::GetWindows())
|
2019-01-09 20:25:19 +00:00
|
|
|
[window->GetNativeWindow().GetNativeNSWindow() setCanHide:NO];
|
2014-06-25 03:55:33 +00:00
|
|
|
|
2018-04-20 18:47:04 +00:00
|
|
|
ProcessSerialNumber psn = {0, kCurrentProcess};
|
2014-06-25 03:55:33 +00:00
|
|
|
TransformProcessType(&psn, kProcessTransformToUIElementApplication);
|
|
|
|
}
|
|
|
|
|
2016-08-01 22:22:37 +00:00
|
|
|
bool Browser::DockIsVisible() {
|
|
|
|
// Because DockShow has a slight delay this may not be true immediately
|
|
|
|
// after that call.
|
2018-04-20 18:47:04 +00:00
|
|
|
return ([[NSRunningApplication currentApplication] activationPolicy] ==
|
|
|
|
NSApplicationActivationPolicyRegular);
|
2016-08-01 22:22:37 +00:00
|
|
|
}
|
|
|
|
|
2019-02-13 05:06:33 +00:00
|
|
|
v8::Local<v8::Promise> Browser::DockShow(v8::Isolate* isolate) {
|
2020-09-03 11:46:24 +00:00
|
|
|
last_dock_show_ = base::Time::Now();
|
2019-11-01 06:10:32 +00:00
|
|
|
gin_helper::Promise<void> promise(isolate);
|
2019-02-21 12:32:44 +00:00
|
|
|
v8::Local<v8::Promise> handle = promise.GetHandle();
|
|
|
|
|
2015-12-17 20:00:04 +00:00
|
|
|
BOOL active = [[NSRunningApplication currentApplication] isActive];
|
2018-04-20 18:47:04 +00:00
|
|
|
ProcessSerialNumber psn = {0, kCurrentProcess};
|
2015-12-17 20:00:04 +00:00
|
|
|
if (active) {
|
2015-12-21 02:52:49 +00:00
|
|
|
// Workaround buggy behavior of TransformProcessType.
|
|
|
|
// http://stackoverflow.com/questions/7596643/
|
|
|
|
NSArray* runningApps = [NSRunningApplication
|
|
|
|
runningApplicationsWithBundleIdentifier:@"com.apple.dock"];
|
|
|
|
for (NSRunningApplication* app in runningApps) {
|
2015-12-17 20:00:04 +00:00
|
|
|
[app activateWithOptions:NSApplicationActivateIgnoringOtherApps];
|
|
|
|
break;
|
|
|
|
}
|
2019-11-01 06:10:32 +00:00
|
|
|
__block gin_helper::Promise<void> p = std::move(promise);
|
2015-12-21 02:52:49 +00:00
|
|
|
dispatch_time_t one_ms = dispatch_time(DISPATCH_TIME_NOW, USEC_PER_SEC);
|
|
|
|
dispatch_after(one_ms, dispatch_get_main_queue(), ^{
|
2015-12-17 20:00:04 +00:00
|
|
|
TransformProcessType(&psn, kProcessTransformToForegroundApplication);
|
2015-12-21 02:52:49 +00:00
|
|
|
dispatch_time_t one_ms = dispatch_time(DISPATCH_TIME_NOW, USEC_PER_SEC);
|
|
|
|
dispatch_after(one_ms, dispatch_get_main_queue(), ^{
|
|
|
|
[[NSRunningApplication currentApplication]
|
|
|
|
activateWithOptions:NSApplicationActivateIgnoringOtherApps];
|
2019-02-21 12:32:44 +00:00
|
|
|
p.Resolve();
|
2015-12-21 02:52:49 +00:00
|
|
|
});
|
2015-12-17 20:00:04 +00:00
|
|
|
});
|
|
|
|
} else {
|
|
|
|
TransformProcessType(&psn, kProcessTransformToForegroundApplication);
|
2019-02-21 12:32:44 +00:00
|
|
|
promise.Resolve();
|
2015-12-17 20:00:04 +00:00
|
|
|
}
|
2019-02-21 12:32:44 +00:00
|
|
|
return handle;
|
2014-06-25 03:55:33 +00:00
|
|
|
}
|
|
|
|
|
2020-02-04 20:19:40 +00:00
|
|
|
void Browser::DockSetMenu(ElectronMenuModel* model) {
|
|
|
|
ElectronApplicationDelegate* delegate =
|
|
|
|
(ElectronApplicationDelegate*)[NSApp delegate];
|
2014-11-16 15:04:31 +00:00
|
|
|
[delegate setApplicationDockMenu:model];
|
|
|
|
}
|
|
|
|
|
2016-01-23 23:30:14 +00:00
|
|
|
void Browser::DockSetIcon(const gfx::Image& image) {
|
2020-02-21 19:05:03 +00:00
|
|
|
[[AtomApplication sharedApplication]
|
2016-01-23 23:30:14 +00:00
|
|
|
setApplicationIconImage:image.AsNSImage()];
|
|
|
|
}
|
|
|
|
|
2016-10-10 20:30:58 +00:00
|
|
|
void Browser::ShowAboutPanel() {
|
|
|
|
NSDictionary* options = DictionaryValueToNSDictionary(about_panel_options_);
|
2016-11-15 17:36:23 +00:00
|
|
|
|
|
|
|
// Credits must be a NSAttributedString instead of NSString
|
2020-01-28 04:23:02 +00:00
|
|
|
NSString* credits = (NSString*)options[@"Credits"];
|
2016-11-15 17:36:23 +00:00
|
|
|
if (credits != nil) {
|
2020-01-28 04:23:02 +00:00
|
|
|
base::scoped_nsobject<NSMutableDictionary> mutable_options(
|
|
|
|
[options mutableCopy]);
|
|
|
|
base::scoped_nsobject<NSAttributedString> creditString(
|
|
|
|
[[NSAttributedString alloc]
|
|
|
|
initWithString:credits
|
|
|
|
attributes:@{
|
|
|
|
NSForegroundColorAttributeName : [NSColor textColor]
|
|
|
|
}]);
|
|
|
|
|
|
|
|
[mutable_options setValue:creditString forKey:@"Credits"];
|
2016-11-15 17:36:23 +00:00
|
|
|
options = [NSDictionary dictionaryWithDictionary:mutable_options];
|
|
|
|
}
|
|
|
|
|
2020-02-21 19:05:03 +00:00
|
|
|
[[AtomApplication sharedApplication]
|
2016-10-10 20:30:58 +00:00
|
|
|
orderFrontStandardAboutPanelWithOptions:options];
|
|
|
|
}
|
|
|
|
|
2019-10-30 05:30:59 +00:00
|
|
|
void Browser::SetAboutPanelOptions(base::DictionaryValue options) {
|
2016-10-10 20:30:58 +00:00
|
|
|
about_panel_options_.Clear();
|
2016-10-12 17:52:59 +00:00
|
|
|
|
2019-10-30 05:30:59 +00:00
|
|
|
for (auto& pair : options) {
|
|
|
|
std::string& key = pair.first;
|
|
|
|
if (!key.empty() && pair.second->is_string()) {
|
2016-10-12 17:52:59 +00:00
|
|
|
key[0] = base::ToUpperASCII(key[0]);
|
2019-10-30 05:30:59 +00:00
|
|
|
about_panel_options_.Set(key, std::move(pair.second));
|
2016-10-12 17:52:59 +00:00
|
|
|
}
|
|
|
|
}
|
2016-10-10 20:30:58 +00:00
|
|
|
}
|
|
|
|
|
2019-03-14 20:39:52 +00:00
|
|
|
void Browser::ShowEmojiPanel() {
|
2020-02-21 19:05:03 +00:00
|
|
|
[[AtomApplication sharedApplication] orderFrontCharacterPalette:nil];
|
2019-03-14 20:39:52 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
bool Browser::IsEmojiPanelSupported() {
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2020-05-21 15:53:44 +00:00
|
|
|
bool Browser::IsSecureKeyboardEntryEnabled() {
|
|
|
|
return password_input_enabler_.get() != nullptr;
|
|
|
|
}
|
|
|
|
|
|
|
|
void Browser::SetSecureKeyboardEntryEnabled(bool enabled) {
|
|
|
|
if (enabled) {
|
|
|
|
password_input_enabler_ =
|
|
|
|
std::make_unique<ui::ScopedPasswordInputEnabler>();
|
|
|
|
} else {
|
|
|
|
password_input_enabler_.reset();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-06-19 21:23:04 +00:00
|
|
|
} // namespace electron
|