mirrors/electron
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages 1 Wiki Activity Actions

Remove a bunch of stuff we don't need in process_singleton_win

Browse source
This commit is contained in:
Paul Betts 2015-10-19 12:28:06 -07:00
parent 1b3363c811
commit c46579b1ac
1 changed files with 15 additions and 131 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

146
atom/browser/process_singleton_win.cc
View file

@ -33,8 +33,6 @@ namespace {
const char kLockfile[] = "lockfile";
const int kMetroChromeActivationTimeoutMs = 3000;
// A helper class that acquires the given |mutex| while the AutoLockMutex is in
// scope.
class AutoLockMutex {
@ -166,66 +164,14 @@ bool ProcessLaunchNotification(
return true;
}
// Returns true if Chrome needs to be relaunched into Windows 8 immersive mode.
// Following conditions apply:-
// 1. Windows 8 or greater.
// 2. Not in Windows 8 immersive mode.
// 3. Chrome is default browser.
// 4. Process integrity level is not high.
// 5. The profile data directory is the default directory.
// 6. Last used mode was immersive/machine is a tablet.
// TODO(ananta)
// Move this function to a common place as the Windows 8 delegate_execute
// handler can possibly use this.
bool ShouldLaunchInWindows8ImmersiveMode(const base::FilePath& user_data_dir) {
// Returning false from this function doesn't mean we don't launch immersive
// mode in Aura. This function is specifically called in case when we need
// to relaunch desktop launched chrome into immersive mode through 'relaunch'
// menu. In case of Aura, we will use delegate_execute to do the relaunch.
bool TerminateAppWithError() {
// TODO: This is called when the secondary process can't ping the primary
// process. Need to find out what to do here.
return false;
}
bool DisplayShouldKillMessageBox() {
return chrome::ShowMessageBox(
NULL, l10n_util::GetStringUTF16(IDS_PRODUCT_NAME),
l10n_util::GetStringUTF16(IDS_BROWSER_HUNGBROWSER_MESSAGE),
chrome::MESSAGE_BOX_TYPE_QUESTION) !=
chrome::MESSAGE_BOX_RESULT_NO;
}
} // namespace
// Microsoft's Softricity virtualization breaks the sandbox processes.
// So, if we detect the Softricity DLL we use WMI Win32_Process.Create to
// break out of the virtualization environment.
// http://code.google.com/p/chromium/issues/detail?id=43650
bool ProcessSingleton::EscapeVirtualization(
const base::FilePath& user_data_dir) {
if (::GetModuleHandle(L"sftldr_wow64.dll") ||
::GetModuleHandle(L"sftldr.dll")) {
int process_id;
if (!installer::WMIProcess::Launch(::GetCommandLineW(), &process_id))
return false;
is_virtualized_ = true;
// The new window was spawned from WMI, and won't be in the foreground.
// So, first we sleep while the new chrome.exe instance starts (because
// WaitForInputIdle doesn't work here). Then we poll for up to two more
// seconds and make the window foreground if we find it (or we give up).
HWND hwnd = 0;
::Sleep(90);
for (int tries = 200; tries; --tries) {
hwnd = chrome::FindRunningChromeWindow(user_data_dir);
if (hwnd) {
::SetForegroundWindow(hwnd);
break;
}
::Sleep(10);
}
return true;
}
return false;
}
ProcessSingleton::ProcessSingleton(
const base::FilePath& user_data_dir,
const NotificationCallback& notification_callback)
@ -234,7 +180,7 @@ ProcessSingleton::ProcessSingleton(
lock_file_(INVALID_HANDLE_VALUE),
user_data_dir_(user_data_dir),
should_kill_remote_process_callback_(
base::Bind(&DisplayShouldKillMessageBox)) {
base::Bind(&TerminateAppWithError)) {
}
ProcessSingleton::~ProcessSingleton() {
@ -252,13 +198,13 @@ ProcessSingleton::NotifyResult ProcessSingleton::NotifyOtherProcess() {
return PROCESS_NONE;
}
switch (chrome::AttemptToNotifyRunningChrome(remote_window_, false)) {
case chrome::NOTIFY_SUCCESS:
switch (atom::AttemptToNotifyRunningAtom(remote_window_, false)) {
case atom::NOTIFY_SUCCESS:
return PROCESS_NOTIFIED;
case chrome::NOTIFY_FAILED:
case atom::NOTIFY_FAILED:
remote_window_ = NULL;
return PROCESS_NONE;
case chrome::NOTIFY_WINDOW_HUNG:
case atom::NOTIFY_WINDOW_HUNG:
// Fall through and potentially terminate the hung browser.
break;
}
@ -297,8 +243,9 @@ ProcessSingleton::NotifyOtherProcessOrCreate() {
if (result == PROCESS_NONE)
result = PROFILE_IN_USE;
} else {
g_browser_process->platform_part()->PlatformSpecificCommandLineProcessing(
*base::CommandLine::ForCurrentProcess());
// TODO: Figure out how to implement this
//g_browser_process->platform_part()->PlatformSpecificCommandLineProcessing(
// *base::CommandLine::ForCurrentProcess());
}
return result;
}
@ -307,12 +254,10 @@ ProcessSingleton::NotifyOtherProcessOrCreate() {
// isn't one, create a message window with its title set to the profile
// directory path.
bool ProcessSingleton::Create() {
static const wchar_t kMutexName[] = L"Local\\ChromeProcessSingletonStartup!";
static const wchar_t kMetroActivationEventName[] =
L"Local\\ChromeProcessSingletonStartupMetroActivation!";
static const wchar_t kMutexName[] = L"Local\\AtomProcessSingletonStartup!";
remote_window_ = chrome::FindRunningChromeWindow(user_data_dir_);
if (!remote_window_ && !EscapeVirtualization(user_data_dir_)) {
remote_window_ = atom::FindRunningAtomWindow(user_data_dir_);
if (!remote_window_) {
// Make sure we will be the one and only process creating the window.
// We use a named Mutex since we are protecting against multi-process
// access. As documented, it's clearer to NOT request ownership on creation
@ -330,59 +275,7 @@ bool ProcessSingleton::Create() {
// window at this time, but we must still check if someone created it
// between the time where we looked for it above and the time the mutex
// was given to us.
remote_window_ = chrome::FindRunningChromeWindow(user_data_dir_);
// In Win8+, a new Chrome process launched in Desktop mode may need to be
// transmuted into Metro Chrome (see ShouldLaunchInWindows8ImmersiveMode for
// heuristics). To accomplish this, the current Chrome activates Metro
// Chrome, releases the startup mutex, and waits for metro Chrome to take
// the singleton. From that point onward, the command line for this Chrome
// process will be sent to Metro Chrome by the usual channels.
if (!remote_window_ && base::win::GetVersion() >= base::win::VERSION_WIN8 &&
!base::win::IsMetroProcess()) {
// |metro_activation_event| is created right before activating a Metro
// Chrome (note that there can only be one Metro Chrome process; by OS
// design); all following Desktop processes will then wait for this event
// to be signaled by Metro Chrome which will do so as soon as it grabs
// this singleton (should any of the waiting processes timeout waiting for
// the signal they will try to grab the singleton for themselves which
// will result in a forced Desktop Chrome launch in the worst case).
base::win::ScopedHandle metro_activation_event(
::OpenEvent(SYNCHRONIZE, FALSE, kMetroActivationEventName));
if (!metro_activation_event.IsValid() &&
ShouldLaunchInWindows8ImmersiveMode(user_data_dir_)) {
// No Metro activation is under way, but the desire is to launch in
// Metro mode: activate and rendez-vous with the activated process.
metro_activation_event.Set(
::CreateEvent(NULL, TRUE, FALSE, kMetroActivationEventName));
if (!chrome::ActivateMetroChrome()) {
// Failed to launch immersive Chrome, default to launching on Desktop.
LOG(ERROR) << "Failed to launch immersive chrome";
metro_activation_event.Close();
}
}
if (metro_activation_event.IsValid()) {
// Release |only_me| (to let Metro Chrome grab this singleton) and wait
// until the event is signaled (i.e. Metro Chrome was successfully
// activated). Ignore timeout waiting for |metro_activation_event|.
{
AutoUnlockMutex auto_unlock_only_me(only_me.Get());
DWORD result = ::WaitForSingleObject(metro_activation_event.Get(),
kMetroChromeActivationTimeoutMs);
DPCHECK(result == WAIT_OBJECT_0 || result == WAIT_TIMEOUT)
<< "Result = " << result;
}
// Check if this singleton was successfully grabbed by another process
// (hopefully Metro Chrome). Failing to do so, this process will grab
// the singleton and launch in Desktop mode.
remote_window_ = chrome::FindRunningChromeWindow(user_data_dir_);
}
}
remote_window_ = atom::FindRunningAtomWindow(user_data_dir_);
if (!remote_window_) {
// We have to make sure there is no Chrome instance running on another
// machine that uses the same profile.
@ -409,15 +302,6 @@ bool ProcessSingleton::Create() {
user_data_dir_.value());
CHECK(result && window_.hwnd());
}
if (base::win::GetVersion() >= base::win::VERSION_WIN8) {
// Make sure no one is still waiting on Metro activation whether it
// succeeded (i.e., this is the Metro process) or failed.
base::win::ScopedHandle metro_activation_event(
::OpenEvent(EVENT_MODIFY_STATE, FALSE, kMetroActivationEventName));
if (metro_activation_event.IsValid())
::SetEvent(metro_activation_event.Get());
}
}
}