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
|
|
|
|
2018-09-13 00:25:56 +00:00
|
|
|
#include <memory>
|
2014-03-16 01:13:06 +00:00
|
|
|
#include <string>
|
2018-10-03 21:47:00 +00:00
|
|
|
#include <utility>
|
2014-03-16 01:13:06 +00:00
|
|
|
|
2016-04-29 11:20:52 +00:00
|
|
|
#include "base/files/file_util.h"
|
2017-08-07 22:38:17 +00:00
|
|
|
#include "base/message_loop/message_loop.h"
|
2018-10-03 21:47:00 +00:00
|
|
|
#include "base/no_destructor.h"
|
2016-04-29 11:20:52 +00:00
|
|
|
#include "base/path_service.h"
|
2017-01-24 03:38:46 +00:00
|
|
|
#include "base/run_loop.h"
|
2018-01-03 10:05:16 +00:00
|
|
|
#include "base/threading/thread_restrictions.h"
|
2016-11-30 07:30:03 +00:00
|
|
|
#include "base/threading/thread_task_runner_handle.h"
|
2019-06-19 20:46:59 +00:00
|
|
|
#include "shell/browser/atom_browser_main_parts.h"
|
|
|
|
#include "shell/browser/atom_paths.h"
|
|
|
|
#include "shell/browser/browser_observer.h"
|
|
|
|
#include "shell/browser/login_handler.h"
|
|
|
|
#include "shell/browser/native_window.h"
|
|
|
|
#include "shell/browser/window_list.h"
|
|
|
|
#include "shell/common/application_info.h"
|
2013-05-02 15:43:23 +00:00
|
|
|
|
|
|
|
namespace atom {
|
|
|
|
|
2018-04-17 23:37:22 +00:00
|
|
|
Browser::LoginItemSettings::LoginItemSettings() = default;
|
|
|
|
Browser::LoginItemSettings::~LoginItemSettings() = default;
|
2018-05-21 22:18:38 +00:00
|
|
|
Browser::LoginItemSettings::LoginItemSettings(const LoginItemSettings& other) =
|
|
|
|
default;
|
2018-04-17 23:37:22 +00:00
|
|
|
|
2018-05-21 22:18:38 +00:00
|
|
|
Browser::Browser() {
|
2013-05-02 15:43:23 +00:00
|
|
|
WindowList::AddObserver(this);
|
|
|
|
}
|
|
|
|
|
|
|
|
Browser::~Browser() {
|
|
|
|
WindowList::RemoveObserver(this);
|
|
|
|
}
|
|
|
|
|
|
|
|
// static
|
|
|
|
Browser* Browser::Get() {
|
|
|
|
return AtomBrowserMainParts::Get()->browser();
|
|
|
|
}
|
|
|
|
|
|
|
|
void Browser::Quit() {
|
2015-10-04 11:20:52 +00:00
|
|
|
if (is_quiting_)
|
|
|
|
return;
|
|
|
|
|
2015-02-26 03:33:42 +00:00
|
|
|
is_quiting_ = HandleBeforeQuit();
|
|
|
|
if (!is_quiting_)
|
|
|
|
return;
|
2013-06-26 09:22:24 +00:00
|
|
|
|
2017-04-06 21:48:58 +00:00
|
|
|
if (atom::WindowList::IsEmpty())
|
2014-04-10 07:22:17 +00:00
|
|
|
NotifyAndShutdown();
|
2017-04-06 21:48:58 +00:00
|
|
|
else
|
|
|
|
atom::WindowList::CloseAllWindows();
|
2013-05-02 15:43:23 +00:00
|
|
|
}
|
|
|
|
|
2016-08-30 03:30:56 +00:00
|
|
|
void Browser::Exit(mate::Arguments* args) {
|
|
|
|
int code = 0;
|
|
|
|
args->GetNext(&code);
|
|
|
|
|
2015-11-06 10:27:13 +00:00
|
|
|
if (!AtomBrowserMainParts::Get()->SetExitCode(code)) {
|
|
|
|
// Message loop is not ready, quit directly.
|
|
|
|
exit(code);
|
|
|
|
} else {
|
2016-03-31 14:12:03 +00:00
|
|
|
// Prepare to quit when all windows have been closed.
|
2015-11-06 10:27:13 +00:00
|
|
|
is_quiting_ = true;
|
|
|
|
|
2016-03-31 14:12:03 +00:00
|
|
|
// Remember this caller so that we don't emit unrelated events.
|
|
|
|
is_exiting_ = true;
|
|
|
|
|
2015-11-06 10:27:13 +00:00
|
|
|
// Must destroy windows before quitting, otherwise bad things can happen.
|
2017-04-06 21:48:58 +00:00
|
|
|
if (atom::WindowList::IsEmpty()) {
|
2015-12-10 03:22:55 +00:00
|
|
|
Shutdown();
|
2015-11-06 10:27:13 +00:00
|
|
|
} else {
|
|
|
|
// Unlike Quit(), we do not ask to close window, but destroy the window
|
|
|
|
// without asking.
|
2017-04-06 21:25:22 +00:00
|
|
|
atom::WindowList::DestroyAllWindows();
|
2015-11-06 10:27:13 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-04-10 07:22:17 +00:00
|
|
|
void Browser::Shutdown() {
|
2015-10-04 11:20:52 +00:00
|
|
|
if (is_shutdown_)
|
|
|
|
return;
|
2014-09-25 13:47:54 +00:00
|
|
|
|
2015-10-04 11:20:52 +00:00
|
|
|
is_shutdown_ = true;
|
2014-04-10 07:22:17 +00:00
|
|
|
is_quiting_ = true;
|
2015-10-04 11:20:52 +00:00
|
|
|
|
2017-01-24 03:34:39 +00:00
|
|
|
for (BrowserObserver& observer : observers_)
|
|
|
|
observer.OnQuit();
|
2015-10-22 08:06:37 +00:00
|
|
|
|
2019-02-01 15:21:49 +00:00
|
|
|
if (quit_main_message_loop_) {
|
|
|
|
std::move(quit_main_message_loop_).Run();
|
2015-10-22 08:06:37 +00:00
|
|
|
} else {
|
2019-02-01 15:21:49 +00:00
|
|
|
// There is no message loop available so we are in early stage, wait until
|
|
|
|
// the quit_main_message_loop_ is available.
|
|
|
|
// Exiting now would leave defunct processes behind.
|
2015-10-22 08:06:37 +00:00
|
|
|
}
|
2014-04-10 07:22:17 +00:00
|
|
|
}
|
|
|
|
|
2013-12-05 02:26:01 +00:00
|
|
|
std::string Browser::GetVersion() const {
|
2018-10-24 10:49:10 +00:00
|
|
|
std::string ret = GetOverriddenApplicationVersion();
|
2018-02-20 16:16:51 +00:00
|
|
|
if (ret.empty())
|
|
|
|
ret = GetExecutableFileVersion();
|
|
|
|
return ret;
|
2013-12-05 02:26:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void Browser::SetVersion(const std::string& version) {
|
2018-10-24 10:49:10 +00:00
|
|
|
OverrideApplicationVersion(version);
|
2013-12-05 02:26:01 +00:00
|
|
|
}
|
|
|
|
|
2013-12-05 02:32:58 +00:00
|
|
|
std::string Browser::GetName() const {
|
2018-10-24 10:49:10 +00:00
|
|
|
std::string ret = GetOverriddenApplicationName();
|
2018-02-20 16:16:51 +00:00
|
|
|
if (ret.empty())
|
|
|
|
ret = GetExecutableFileProductName();
|
|
|
|
return ret;
|
2013-12-05 02:32:58 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void Browser::SetName(const std::string& name) {
|
2018-10-24 10:49:10 +00:00
|
|
|
OverrideApplicationName(name);
|
2013-12-05 02:32:58 +00:00
|
|
|
}
|
|
|
|
|
2016-07-01 08:39:01 +00:00
|
|
|
int Browser::GetBadgeCount() {
|
2016-07-02 01:36:11 +00:00
|
|
|
return badge_count_;
|
2016-07-01 08:39:01 +00:00
|
|
|
}
|
|
|
|
|
2013-05-30 08:03:10 +00:00
|
|
|
bool Browser::OpenFile(const std::string& file_path) {
|
|
|
|
bool prevent_default = false;
|
2017-01-24 03:34:39 +00:00
|
|
|
for (BrowserObserver& observer : observers_)
|
|
|
|
observer.OnOpenFile(&prevent_default, file_path);
|
2013-05-30 08:03:10 +00:00
|
|
|
|
|
|
|
return prevent_default;
|
|
|
|
}
|
|
|
|
|
2013-07-10 08:10:38 +00:00
|
|
|
void Browser::OpenURL(const std::string& url) {
|
2017-01-24 03:34:39 +00:00
|
|
|
for (BrowserObserver& observer : observers_)
|
|
|
|
observer.OnOpenURL(url);
|
2013-07-10 08:10:38 +00:00
|
|
|
}
|
|
|
|
|
2015-09-15 02:05:53 +00:00
|
|
|
void Browser::Activate(bool has_visible_windows) {
|
2017-01-24 03:34:39 +00:00
|
|
|
for (BrowserObserver& observer : observers_)
|
|
|
|
observer.OnActivate(has_visible_windows);
|
2015-09-14 11:28:13 +00:00
|
|
|
}
|
|
|
|
|
2013-06-03 07:31:46 +00:00
|
|
|
void Browser::WillFinishLaunching() {
|
2017-01-24 03:34:39 +00:00
|
|
|
for (BrowserObserver& observer : observers_)
|
|
|
|
observer.OnWillFinishLaunching();
|
2013-06-03 07:31:46 +00:00
|
|
|
}
|
|
|
|
|
2016-09-01 00:17:44 +00:00
|
|
|
void Browser::DidFinishLaunching(const base::DictionaryValue& launch_info) {
|
2018-01-03 10:05:16 +00:00
|
|
|
// Make sure the userData directory is created.
|
|
|
|
base::ThreadRestrictions::ScopedAllowIO allow_io;
|
|
|
|
base::FilePath user_data;
|
2018-10-24 10:49:10 +00:00
|
|
|
if (base::PathService::Get(DIR_USER_DATA, &user_data))
|
2018-01-03 10:05:16 +00:00
|
|
|
base::CreateDirectoryAndGetError(user_data, nullptr);
|
2017-12-09 17:24:37 +00:00
|
|
|
|
2018-01-03 10:05:16 +00:00
|
|
|
is_ready_ = true;
|
2018-06-27 21:06:08 +00:00
|
|
|
if (ready_promise_) {
|
|
|
|
ready_promise_->Resolve();
|
|
|
|
}
|
2018-01-03 10:05:16 +00:00
|
|
|
for (BrowserObserver& observer : observers_)
|
|
|
|
observer.OnFinishLaunching(launch_info);
|
2015-06-11 15:22:07 +00:00
|
|
|
}
|
|
|
|
|
2019-02-21 12:32:44 +00:00
|
|
|
const util::Promise& Browser::WhenReady(v8::Isolate* isolate) {
|
2018-06-27 21:06:08 +00:00
|
|
|
if (!ready_promise_) {
|
2019-02-21 12:32:44 +00:00
|
|
|
ready_promise_.reset(new util::Promise(isolate));
|
2018-06-27 21:06:08 +00:00
|
|
|
if (is_ready()) {
|
|
|
|
ready_promise_->Resolve();
|
|
|
|
}
|
|
|
|
}
|
2019-02-21 12:32:44 +00:00
|
|
|
return *ready_promise_;
|
2018-06-27 21:06:08 +00:00
|
|
|
}
|
|
|
|
|
2016-07-11 21:32:14 +00:00
|
|
|
void Browser::OnAccessibilitySupportChanged() {
|
2017-01-24 03:34:39 +00:00
|
|
|
for (BrowserObserver& observer : observers_)
|
|
|
|
observer.OnAccessibilitySupportChanged();
|
2016-07-11 21:04:56 +00:00
|
|
|
}
|
|
|
|
|
2016-06-08 13:52:21 +00:00
|
|
|
void Browser::RequestLogin(
|
2018-08-23 09:55:13 +00:00
|
|
|
scoped_refptr<LoginHandler> login_handler,
|
2016-06-08 13:52:21 +00:00
|
|
|
std::unique_ptr<base::DictionaryValue> request_details) {
|
2017-01-24 03:34:39 +00:00
|
|
|
for (BrowserObserver& observer : observers_)
|
|
|
|
observer.OnLogin(login_handler, *(request_details.get()));
|
2015-10-28 11:34:01 +00:00
|
|
|
}
|
|
|
|
|
2017-12-22 15:55:57 +00:00
|
|
|
void Browser::PreMainMessageLoopRun() {
|
|
|
|
for (BrowserObserver& observer : observers_) {
|
|
|
|
observer.OnPreMainMessageLoopRun();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-10-03 21:47:00 +00:00
|
|
|
void Browser::SetMainMessageLoopQuitClosure(base::OnceClosure quit_closure) {
|
2019-02-01 15:21:49 +00:00
|
|
|
if (is_shutdown_)
|
|
|
|
std::move(quit_closure).Run();
|
|
|
|
else
|
|
|
|
quit_main_message_loop_ = std::move(quit_closure);
|
2018-10-03 21:47:00 +00:00
|
|
|
}
|
|
|
|
|
2014-04-10 07:22:17 +00:00
|
|
|
void Browser::NotifyAndShutdown() {
|
2015-10-04 11:20:52 +00:00
|
|
|
if (is_shutdown_)
|
|
|
|
return;
|
|
|
|
|
2013-05-03 02:53:54 +00:00
|
|
|
bool prevent_default = false;
|
2017-01-24 03:34:39 +00:00
|
|
|
for (BrowserObserver& observer : observers_)
|
|
|
|
observer.OnWillQuit(&prevent_default);
|
2013-05-03 02:53:54 +00:00
|
|
|
|
2013-06-26 09:22:24 +00:00
|
|
|
if (prevent_default) {
|
|
|
|
is_quiting_ = false;
|
2013-05-03 02:53:54 +00:00
|
|
|
return;
|
2013-06-26 09:22:24 +00:00
|
|
|
}
|
2013-05-03 02:53:54 +00:00
|
|
|
|
2014-04-10 07:22:17 +00:00
|
|
|
Shutdown();
|
2013-05-03 02:53:54 +00:00
|
|
|
}
|
|
|
|
|
2015-02-26 03:33:42 +00:00
|
|
|
bool Browser::HandleBeforeQuit() {
|
|
|
|
bool prevent_default = false;
|
2017-01-24 03:34:39 +00:00
|
|
|
for (BrowserObserver& observer : observers_)
|
|
|
|
observer.OnBeforeQuit(&prevent_default);
|
2015-02-26 03:33:42 +00:00
|
|
|
|
|
|
|
return !prevent_default;
|
|
|
|
}
|
|
|
|
|
2013-05-02 15:43:23 +00:00
|
|
|
void Browser::OnWindowCloseCancelled(NativeWindow* window) {
|
2014-04-14 16:02:33 +00:00
|
|
|
if (is_quiting_)
|
2013-06-26 09:22:24 +00:00
|
|
|
// Once a beforeunload handler has prevented the closing, we think the quit
|
|
|
|
// is cancelled too.
|
|
|
|
is_quiting_ = false;
|
2013-05-02 15:43:23 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void Browser::OnWindowAllClosed() {
|
2017-01-24 03:34:39 +00:00
|
|
|
if (is_exiting_) {
|
2016-03-31 14:12:03 +00:00
|
|
|
Shutdown();
|
2017-01-24 03:34:39 +00:00
|
|
|
} else if (is_quiting_) {
|
2014-04-10 07:22:17 +00:00
|
|
|
NotifyAndShutdown();
|
2017-01-24 03:34:39 +00:00
|
|
|
} else {
|
|
|
|
for (BrowserObserver& observer : observers_)
|
|
|
|
observer.OnWindowAllClosed();
|
|
|
|
}
|
2013-05-02 15:43:23 +00:00
|
|
|
}
|
|
|
|
|
2017-06-11 08:19:01 +00:00
|
|
|
#if defined(OS_MACOSX)
|
|
|
|
void Browser::NewWindowForTab() {
|
|
|
|
for (BrowserObserver& observer : observers_)
|
|
|
|
observer.OnNewWindowForTab();
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2013-05-02 15:43:23 +00:00
|
|
|
} // namespace atom
|