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

feat: Add first-instance-ack event to the app.requestSingleInstanceLock() flow (#31460)

Browse source 
* feat: Add onFirstInstanceAck event for requestSingleInstanceLock

* Add tests

* Apply patch fix

* Add back missing docs

* Rebase

* Listen for exit earlier in test

* Rebase
This commit is contained in:
Raymond Zhao 2022-01-10 08:54:46 -08:00 committed by GitHub
parent 7c16ef1f62
commit 746927c972
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
7 changed files with 514 additions and 92 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

38
docs/api/app.md
View file

@ -484,6 +484,7 @@ Returns:
* `argv` string[] - An array of the second instance's command line arguments * `argv` string[] - An array of the second instance's command line arguments
* `workingDirectory` string - The second instance's working directory * `workingDirectory` string - The second instance's working directory
* `additionalData` unknown - A JSON object of additional data passed from the second instance * `additionalData` unknown - A JSON object of additional data passed from the second instance
* `ackCallback` unknown - A function that can be used to send data back to the second instance
This event will be emitted inside the primary instance of your application This event will be emitted inside the primary instance of your application
when a second instance has been executed and calls `app.requestSingleInstanceLock()`. when a second instance has been executed and calls `app.requestSingleInstanceLock()`.
@ -495,12 +496,35 @@ non-minimized.
**Note:** If the second instance is started by a different user than the first, the `argv` array will not include the arguments. **Note:** If the second instance is started by a different user than the first, the `argv` array will not include the arguments.
**Note:** `ackCallback` allows the user to send data back to the
second instance during the `app.requestSingleInstanceLock()` flow.
This callback can be used for cases where the second instance
needs to obtain additional information from the first instance
before quitting.
Currently, the limit on the message size is kMaxMessageLength,
or around 32kB. To be safe, keep the amount of data passed to 31kB at most.
In order to call the callback, `event.preventDefault()` must be called, first.
If the callback is not called in either case, `null` will be sent back.
If `event.preventDefault()` is not called, but `ackCallback` is called
by the user in the event, then the behaviour is undefined.
This event is guaranteed to be emitted after the `ready` event of `app` This event is guaranteed to be emitted after the `ready` event of `app`
gets emitted. gets emitted.
**Note:** Extra command line arguments might be added by Chromium, **Note:** Extra command line arguments might be added by Chromium,
such as `--original-process-start-time`. such as `--original-process-start-time`.
### Event: 'first-instance-ack'
Returns:
* `event` Event
* `additionalData` unknown - A JSON object of additional data passed from the first instance, in response to the first instance's `second-instance` event.
This event will be emitted within the second instance during the call to `app.requestSingleInstanceLock()`, when the first instance calls the `ackCallback` provided by the `second-instance` event handler.
## Methods ## Methods
The `app` object has the following methods: The `app` object has the following methods:
@ -959,6 +983,13 @@ starts:
const { app } = require('electron') const { app } = require('electron')
let myWindow = null let myWindow = null
app.on('first-instance-ack', (event, additionalData) => {
// Print out the ack received from the first instance.
// Note this event handler must come before the requestSingleInstanceLock call.
// Expected output: '{"myAckKey":"myAckValue"}'
console.log(JSON.stringify(additionalData))
})
const additionalData = { myKey: 'myValue' } const additionalData = { myKey: 'myValue' }
const gotTheLock = app.requestSingleInstanceLock(additionalData) const gotTheLock = app.requestSingleInstanceLock(additionalData)
@ -966,14 +997,19 @@ if (!gotTheLock) {
app.quit() app.quit()
} else { } else {
app.on('second-instance', (event, commandLine, workingDirectory, additionalData) => { app.on('second-instance', (event, commandLine, workingDirectory, additionalData) => {
// We must call preventDefault if we're sending back data.
event.preventDefault()
// Print out data received from the second instance. // Print out data received from the second instance.
console.log(additionalData) // Expected output: '{"myKey":"myValue"}'
console.log(JSON.stringify(additionalData))
// Someone tried to run a second instance, we should focus our window. // Someone tried to run a second instance, we should focus our window.
if (myWindow) { if (myWindow) {
if (myWindow.isMinimized()) myWindow.restore() if (myWindow.isMinimized()) myWindow.restore()
myWindow.focus() myWindow.focus()
} }
const ackData = { myAckKey: 'myAckValue' }
ackCallback(ackData)
}) })
// Create myWindow, load the rest of the app, etc... // Create myWindow, load the rest of the app, etc...

2
patches/chromium/.patches
View file

@ -106,8 +106,8 @@ chore_do_not_use_chrome_windows_in_cryptotoken_webrequestsender.patch
process_singleton.patch process_singleton.patch
fix_expose_decrementcapturercount_in_web_contents_impl.patch fix_expose_decrementcapturercount_in_web_contents_impl.patch
add_ui_scopedcliboardwriter_writeunsaferawdata.patch add_ui_scopedcliboardwriter_writeunsaferawdata.patch
feat_add_data_parameter_to_processsingleton.patch
mas_gate_private_enterprise_APIs.patch mas_gate_private_enterprise_APIs.patch
load_v8_snapshot_in_browser_process.patch load_v8_snapshot_in_browser_process.patch
fix_patch_out_permissions_checks_in_exclusive_access.patch fix_patch_out_permissions_checks_in_exclusive_access.patch
fix_aspect_ratio_with_max_size.patch fix_aspect_ratio_with_max_size.patch
feat_add_data_transfer_to_requestsingleinstancelock.patch

332
patches/chromium/feat_add_data_parameter_to_processsingleton.patch → patches/chromium/feat_add_data_transfer_to_requestsingleinstancelock.patch
View file

@ -1,19 +1,25 @@
From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
From: Raymond Zhao <raymondzhao@microsoft.com> From: Raymond Zhao <raymondzhao@microsoft.com>
Date: Tue, 7 Sep 2021 14:54:25 -0700 Date: Tue, 7 Sep 2021 14:54:25 -0700
Subject: feat: Add data parameter to ProcessSingleton Subject: feat: Add data transfer mechanism to requestSingleInstanceLock flow
This patch adds an additional_data parameter to the constructor of This patch adds code that allows for the second instance to send
ProcessSingleton, so that the second instance can send additional additional data to the first instance, and for the first instance
data over to the first instance while requesting the ProcessSingleton to send additional data back to the second instance, during the
lock. app.requestSingleInstanceLock call.
On the Electron side, we then expose an extra parameter to the Firstly, this patch adds an additional_data parameter
app.requestSingleInstanceLock API so that users can pass in a JSON to the constructor of ProcessSingleton, so that the second instance
object for the second instance to send to the first instance. can send additional data over to the first instance
while requesting the ProcessSingleton lock.
Then, we add additional processing to the second-instance event, both
so the first instance can receive additional data from the second
instance, but also so the second instance can send back additional
data to the first instance if needed.
diff --git a/chrome/browser/process_singleton.h b/chrome/browser/process_singleton.h diff --git a/chrome/browser/process_singleton.h b/chrome/browser/process_singleton.h
index 13b325ecad9ba48398173e89680287c63efd4fa6..2061374805de9f9e646b896c4212bb3dcf2b8ed7 100644 index 13b325ecad9ba48398173e89680287c63efd4fa6..e8188e4640b28d41559822e6c1bdd27dcccae93c 100644
--- a/chrome/browser/process_singleton.h --- a/chrome/browser/process_singleton.h
+++ b/chrome/browser/process_singleton.h +++ b/chrome/browser/process_singleton.h
@@ -18,6 +18,7 @@ @@ -18,6 +18,7 @@
@ -24,24 +30,39 @@ index 13b325ecad9ba48398173e89680287c63efd4fa6..2061374805de9f9e646b896c4212bb3d
#include "ui/gfx/native_widget_types.h" #include "ui/gfx/native_widget_types.h"
#if defined(OS_POSIX) && !defined(OS_ANDROID) #if defined(OS_POSIX) && !defined(OS_ANDROID)
@@ -100,21 +101,24 @@ class ProcessSingleton { @@ -93,6 +94,9 @@ class ProcessSingleton {
static constexpr int kNumNotifyResults = LAST_VALUE + 1;
+ using NotificationAckCallback =
+ base::RepeatingCallback<void(const base::span<const uint8_t>* ack_data)>;
+
// Implement this callback to handle notifications from other processes. The
// callback will receive the command line and directory with which the other
// Chrome process was launched. Return true if the command line will be
@@ -100,21 +104,27 @@ class ProcessSingleton {
// should handle it (i.e., because the current process is shutting down). // should handle it (i.e., because the current process is shutting down).
using NotificationCallback = using NotificationCallback =
base::RepeatingCallback<bool(const base::CommandLine& command_line, base::RepeatingCallback<bool(const base::CommandLine& command_line,
- const base::FilePath& current_directory)>; - const base::FilePath& current_directory)>;
+ const base::FilePath& current_directory, + const base::FilePath& current_directory,
+ const std::vector<const uint8_t> additional_data)>; + const std::vector<const uint8_t> additional_data,
+ const NotificationAckCallback& ack_callback)>;
#if defined(OS_WIN) #if defined(OS_WIN)
ProcessSingleton(const std::string& program_name, ProcessSingleton(const std::string& program_name,
const base::FilePath& user_data_dir, const base::FilePath& user_data_dir,
+ const base::span<const uint8_t> additional_data, + const base::span<const uint8_t> additional_data,
bool is_sandboxed, bool is_sandboxed,
const NotificationCallback& notification_callback); - const NotificationCallback& notification_callback);
+ const NotificationCallback& notification_callback,
+ const NotificationAckCallback& ack_notification_callback);
#else #else
ProcessSingleton(const base::FilePath& user_data_dir, ProcessSingleton(const base::FilePath& user_data_dir,
- const NotificationCallback& notification_callback);
+ const base::span<const uint8_t> additional_data, + const base::span<const uint8_t> additional_data,
const NotificationCallback& notification_callback); + const NotificationCallback& notification_callback,
+ const NotificationAckCallback& ack_notification_callback);
+#endif +#endif
ProcessSingleton(const ProcessSingleton&) = delete; ProcessSingleton(const ProcessSingleton&) = delete;
@ -51,19 +72,42 @@ index 13b325ecad9ba48398173e89680287c63efd4fa6..2061374805de9f9e646b896c4212bb3d
~ProcessSingleton(); ~ProcessSingleton();
// Notify another process, if available. Otherwise sets ourselves as the // Notify another process, if available. Otherwise sets ourselves as the
@@ -178,6 +182,8 @@ class ProcessSingleton { @@ -177,7 +187,13 @@ class ProcessSingleton {
#endif
private: private:
NotificationCallback notification_callback_; // Handler for notifications. - NotificationCallback notification_callback_; // Handler for notifications.
+ // A callback to run when the first instance receives data from the second.
+ NotificationCallback notification_callback_;
+ // A callback to run when the second instance
+ // receives an acknowledgement from the first.
+ NotificationAckCallback notification_ack_callback_;
+ // Custom data to pass to the other instance during notify. + // Custom data to pass to the other instance during notify.
+ base::span<const uint8_t> additional_data_; + base::span<const uint8_t> additional_data_;
#if defined(OS_WIN) #if defined(OS_WIN)
bool EscapeVirtualization(const base::FilePath& user_data_dir); bool EscapeVirtualization(const base::FilePath& user_data_dir);
@@ -190,6 +206,7 @@ class ProcessSingleton {
HANDLE lock_file_;
base::FilePath user_data_dir_;
ShouldKillRemoteProcessCallback should_kill_remote_process_callback_;
+ HANDLE ack_pipe_;
#elif defined(OS_POSIX) && !defined(OS_ANDROID)
// Return true if the given pid is one of our child processes.
// Assumes that the current pid is the root of all pids of the current
diff --git a/chrome/browser/process_singleton_posix.cc b/chrome/browser/process_singleton_posix.cc diff --git a/chrome/browser/process_singleton_posix.cc b/chrome/browser/process_singleton_posix.cc
index 0d74cd93a21b937f65f3d417b4734ae5b87acdf2..66a4369747377fe64c91b68f57ee4178c426ea61 100644 index 0d74cd93a21b937f65f3d417b4734ae5b87acdf2..9bf6e633b5adc68a67d23e4f17460dce24a02cfa 100644
--- a/chrome/browser/process_singleton_posix.cc --- a/chrome/browser/process_singleton_posix.cc
+++ b/chrome/browser/process_singleton_posix.cc +++ b/chrome/browser/process_singleton_posix.cc
@@ -147,7 +147,7 @@ const char kACKToken[] = "ACK";
const char kShutdownToken[] = "SHUTDOWN";
const char kTokenDelimiter = '\0';
const int kMaxMessageLength = 32 * 1024;
-const int kMaxACKMessageLength = base::size(kShutdownToken) - 1;
+const int kMaxACKMessageLength = kMaxMessageLength;
bool g_disable_prompt = false;
bool g_skip_is_chrome_process_check = false;
@@ -627,6 +627,7 @@ class ProcessSingleton::LinuxWatcher @@ -627,6 +627,7 @@ class ProcessSingleton::LinuxWatcher
// |reader| is for sending back ACK message. // |reader| is for sending back ACK message.
void HandleMessage(const std::string& current_dir, void HandleMessage(const std::string& current_dir,
@ -72,7 +116,17 @@ index 0d74cd93a21b937f65f3d417b4734ae5b87acdf2..66a4369747377fe64c91b68f57ee4178
SocketReader* reader); SocketReader* reader);
private: private:
@@ -681,13 +682,16 @@ void ProcessSingleton::LinuxWatcher::StartListening(int socket) { @@ -651,6 +652,9 @@ class ProcessSingleton::LinuxWatcher
// The ProcessSingleton that owns us.
ProcessSingleton* const parent_;
+ bool ack_callback_called_ = false;
+ void AckCallback(SocketReader* reader, const base::span<const uint8_t>* response);
+
std::set<std::unique_ptr<SocketReader>, base::UniquePtrComparator> readers_;
};
@@ -681,16 +685,21 @@ void ProcessSingleton::LinuxWatcher::StartListening(int socket) {
} }
void ProcessSingleton::LinuxWatcher::HandleMessage( void ProcessSingleton::LinuxWatcher::HandleMessage(
@ -84,14 +138,46 @@ index 0d74cd93a21b937f65f3d417b4734ae5b87acdf2..66a4369747377fe64c91b68f57ee4178
DCHECK(ui_task_runner_->BelongsToCurrentThread()); DCHECK(ui_task_runner_->BelongsToCurrentThread());
DCHECK(reader); DCHECK(reader);
if (parent_->notification_callback_.Run(base::CommandLine(argv), - if (parent_->notification_callback_.Run(base::CommandLine(argv),
- base::FilePath(current_dir))) { - base::FilePath(current_dir))) {
- // Send back "ACK" message to prevent the client process from starting up.
- reader->FinishWithACK(kACKToken, base::size(kACKToken) - 1);
- } else {
+ auto wrapped_ack_callback =
+ base::BindRepeating(&ProcessSingleton::LinuxWatcher::AckCallback,
+ base::Unretained(this), reader);
+ ack_callback_called_ = false;
+ if (!parent_->notification_callback_.Run(base::CommandLine(argv),
+ base::FilePath(current_dir), + base::FilePath(current_dir),
+ std::move(additional_data))) { + std::move(additional_data),
// Send back "ACK" message to prevent the client process from starting up. + wrapped_ack_callback)) {
reader->FinishWithACK(kACKToken, base::size(kACKToken) - 1); LOG(WARNING) << "Not handling interprocess notification as browser"
} else { " is shutting down";
@@ -735,7 +739,8 @@ void ProcessSingleton::LinuxWatcher::SocketReader:: // Send back "SHUTDOWN" message, so that the client process can start up
@@ -700,6 +709,22 @@ void ProcessSingleton::LinuxWatcher::HandleMessage(
}
}
+void ProcessSingleton::LinuxWatcher::AckCallback(
+ SocketReader* reader,
+ const base::span<const uint8_t>* response) {
+ // Send back "ACK" message to prevent the client process from starting up.
+ if (!ack_callback_called_) {
+ ack_callback_called_ = true;
+ std::string ack_message;
+ ack_message.append(kACKToken, base::size(kACKToken) - 1);
+ if (response && response->size_bytes()) {
+ ack_message.append(reinterpret_cast<const char*>(response->data()),
+ response->size_bytes());
+ }
+ reader->FinishWithACK(ack_message.c_str(), ack_message.size());
+ }
+}
+
void ProcessSingleton::LinuxWatcher::RemoveSocketReader(SocketReader* reader) {
DCHECK_CURRENTLY_ON(BrowserThread::IO);
DCHECK(reader);
@@ -735,7 +760,8 @@ void ProcessSingleton::LinuxWatcher::SocketReader::
} }
} }
@ -101,7 +187,7 @@ index 0d74cd93a21b937f65f3d417b4734ae5b87acdf2..66a4369747377fe64c91b68f57ee4178
const size_t kMinMessageLength = base::size(kStartToken) + 4; const size_t kMinMessageLength = base::size(kStartToken) + 4;
if (bytes_read_ < kMinMessageLength) { if (bytes_read_ < kMinMessageLength) {
buf_[bytes_read_] = 0; buf_[bytes_read_] = 0;
@@ -765,10 +770,28 @@ void ProcessSingleton::LinuxWatcher::SocketReader:: @@ -765,10 +791,28 @@ void ProcessSingleton::LinuxWatcher::SocketReader::
tokens.erase(tokens.begin()); tokens.erase(tokens.begin());
tokens.erase(tokens.begin()); tokens.erase(tokens.begin());
@ -118,8 +204,8 @@ index 0d74cd93a21b937f65f3d417b4734ae5b87acdf2..66a4369747377fe64c91b68f57ee4178
+ std::string(1, kTokenDelimiter)); + std::string(1, kTokenDelimiter));
+ const uint8_t* additional_data_bits = + const uint8_t* additional_data_bits =
+ reinterpret_cast<const uint8_t*>(remaining_args.c_str()); + reinterpret_cast<const uint8_t*>(remaining_args.c_str());
+ additional_data = std::vector<const uint8_t>( + additional_data = std::vector<const uint8_t>(additional_data_bits,
+ additional_data_bits, additional_data_bits + additional_data_size); + additional_data_bits + additional_data_size);
+ } + }
+ +
// Return to the UI thread to handle opening a new browser tab. // Return to the UI thread to handle opening a new browser tab.
@ -131,18 +217,21 @@ index 0d74cd93a21b937f65f3d417b4734ae5b87acdf2..66a4369747377fe64c91b68f57ee4178
fd_watch_controller_.reset(); fd_watch_controller_.reset();
// LinuxWatcher::HandleMessage() is in charge of destroying this SocketReader // LinuxWatcher::HandleMessage() is in charge of destroying this SocketReader
@@ -797,8 +820,10 @@ void ProcessSingleton::LinuxWatcher::SocketReader::FinishWithACK( @@ -797,8 +841,12 @@ void ProcessSingleton::LinuxWatcher::SocketReader::FinishWithACK(
// //
ProcessSingleton::ProcessSingleton( ProcessSingleton::ProcessSingleton(
const base::FilePath& user_data_dir, const base::FilePath& user_data_dir,
- const NotificationCallback& notification_callback)
+ const base::span<const uint8_t> additional_data, + const base::span<const uint8_t> additional_data,
const NotificationCallback& notification_callback) + const NotificationCallback& notification_callback,
+ const NotificationAckCallback& notification_ack_callback)
: notification_callback_(notification_callback), : notification_callback_(notification_callback),
+ notification_ack_callback_(notification_ack_callback),
+ additional_data_(additional_data), + additional_data_(additional_data),
current_pid_(base::GetCurrentProcId()), current_pid_(base::GetCurrentProcId()),
watcher_(new LinuxWatcher(this)) { watcher_(new LinuxWatcher(this)) {
socket_path_ = user_data_dir.Append(chrome::kSingletonSocketFilename); socket_path_ = user_data_dir.Append(chrome::kSingletonSocketFilename);
@@ -915,7 +940,8 @@ ProcessSingleton::NotifyResult ProcessSingleton::NotifyOtherProcessWithTimeout( @@ -915,7 +963,8 @@ ProcessSingleton::NotifyResult ProcessSingleton::NotifyOtherProcessWithTimeout(
sizeof(socket_timeout)); sizeof(socket_timeout));
// Found another process, prepare our command line // Found another process, prepare our command line
@ -152,7 +241,7 @@ index 0d74cd93a21b937f65f3d417b4734ae5b87acdf2..66a4369747377fe64c91b68f57ee4178
std::string to_send(kStartToken); std::string to_send(kStartToken);
to_send.push_back(kTokenDelimiter); to_send.push_back(kTokenDelimiter);
@@ -925,11 +951,21 @@ ProcessSingleton::NotifyResult ProcessSingleton::NotifyOtherProcessWithTimeout( @@ -925,11 +974,21 @@ ProcessSingleton::NotifyResult ProcessSingleton::NotifyOtherProcessWithTimeout(
to_send.append(current_dir.value()); to_send.append(current_dir.value());
const std::vector<std::string>& argv = cmd_line.argv(); const std::vector<std::string>& argv = cmd_line.argv();
@ -174,11 +263,52 @@ index 0d74cd93a21b937f65f3d417b4734ae5b87acdf2..66a4369747377fe64c91b68f57ee4178
// Send the message // Send the message
if (!WriteToSocket(socket.fd(), to_send.data(), to_send.length())) { if (!WriteToSocket(socket.fd(), to_send.data(), to_send.length())) {
// Try to kill the other process, because it might have been dead. // Try to kill the other process, because it might have been dead.
@@ -969,6 +1028,17 @@ ProcessSingleton::NotifyResult ProcessSingleton::NotifyOtherProcessWithTimeout(
linux_ui->NotifyWindowManagerStartupComplete();
#endif
+ size_t ack_data_len = len - (base::size(kACKToken) - 1);
+ if (ack_data_len) {
+ const uint8_t* raw_ack_data =
+ reinterpret_cast<const uint8_t*>(buf + base::size(kACKToken) - 1);
+ base::span<const uint8_t> ack_data =
+ base::make_span(raw_ack_data, raw_ack_data + ack_data_len);
+ notification_ack_callback_.Run(&ack_data);
+ } else {
+ notification_ack_callback_.Run(nullptr);
+ }
+
// Assume the other process is handling the request.
return PROCESS_NOTIFIED;
}
diff --git a/chrome/browser/process_singleton_win.cc b/chrome/browser/process_singleton_win.cc diff --git a/chrome/browser/process_singleton_win.cc b/chrome/browser/process_singleton_win.cc
index 679350dd08ca0211653ea669405e3f4f86c2fc0f..daab2f170d857082df56966c7bd8abc53924631d 100644 index 679350dd08ca0211653ea669405e3f4f86c2fc0f..16ad742721e9c5af13224f74e864e648c27a2a34 100644
--- a/chrome/browser/process_singleton_win.cc --- a/chrome/browser/process_singleton_win.cc
+++ b/chrome/browser/process_singleton_win.cc +++ b/chrome/browser/process_singleton_win.cc
@@ -98,10 +98,12 @@ BOOL CALLBACK BrowserWindowEnumeration(HWND window, LPARAM param) { @@ -22,6 +22,7 @@
#include "base/strings/utf_string_conversions.h"
#include "base/time/time.h"
#include "base/trace_event/trace_event.h"
+#include "base/timer/timer.h"
#include "base/win/registry.h"
#include "base/win/scoped_handle.h"
#include "base/win/windows_version.h"
@@ -44,6 +45,14 @@
namespace {
const char kLockfile[] = "lockfile";
+const LPCWSTR kPipeName = L"\\\\.\\pipe\\electronAckPipe";
+const DWORD kPipeTimeout = 10000;
+const DWORD kMaxMessageLength = 32 * 1024;
+
+std::unique_ptr<std::vector<const uint8_t>> g_ack_data;
+base::OneShotTimer g_ack_timer;
+HANDLE g_write_ack_pipe;
+bool g_write_ack_callback_called = false;
// A helper class that acquires the given |mutex| while the AutoLockMutex is in
// scope.
@@ -98,10 +107,12 @@ BOOL CALLBACK BrowserWindowEnumeration(HWND window, LPARAM param) {
bool ParseCommandLine(const COPYDATASTRUCT* cds, bool ParseCommandLine(const COPYDATASTRUCT* cds,
base::CommandLine* parsed_command_line, base::CommandLine* parsed_command_line,
@ -193,7 +323,7 @@ index 679350dd08ca0211653ea669405e3f4f86c2fc0f..daab2f170d857082df56966c7bd8abc5
static const int min_message_size = 7; static const int min_message_size = 7;
if (cds->cbData < min_message_size * sizeof(wchar_t) || if (cds->cbData < min_message_size * sizeof(wchar_t) ||
cds->cbData % sizeof(wchar_t) != 0) { cds->cbData % sizeof(wchar_t) != 0) {
@@ -151,6 +153,37 @@ bool ParseCommandLine(const COPYDATASTRUCT* cds, @@ -151,11 +162,82 @@ bool ParseCommandLine(const COPYDATASTRUCT* cds,
const std::wstring cmd_line = const std::wstring cmd_line =
msg.substr(second_null + 1, third_null - second_null); msg.substr(second_null + 1, third_null - second_null);
*parsed_command_line = base::CommandLine::FromString(cmd_line); *parsed_command_line = base::CommandLine::FromString(cmd_line);
@ -231,7 +361,52 @@ index 679350dd08ca0211653ea669405e3f4f86c2fc0f..daab2f170d857082df56966c7bd8abc5
return true; return true;
} }
return false; return false;
@@ -167,16 +200,16 @@ bool ProcessLaunchNotification( }
+void StoreAck(const base::span<const uint8_t>* ack_data) {
+ if (ack_data) {
+ g_ack_data = std::make_unique<std::vector<const uint8_t>>(ack_data->begin(),
+ ack_data->end());
+ } else {
+ g_ack_data = nullptr;
+ }
+}
+
+void SendBackAck() {
+ // This is the first instance sending the ack back to the second instance.
+ if (!g_write_ack_callback_called) {
+ g_write_ack_callback_called = true;
+ const uint8_t* data_buffer = nullptr;
+ DWORD data_to_send_size = 0;
+ if (g_ack_data) {
+ data_buffer = g_ack_data->data();
+ DWORD ack_data_size = g_ack_data->size() * sizeof(uint8_t);
+ data_to_send_size = (ack_data_size < kMaxMessageLength) ? ack_data_size : kMaxMessageLength;
+ }
+
+ ::ConnectNamedPipe(g_write_ack_pipe, NULL);
+
+ DWORD bytes_written = 0;
+ ::WriteFile(g_write_ack_pipe,
+ (LPCVOID)data_buffer,
+ data_to_send_size,
+ &bytes_written,
+ NULL);
+ DCHECK(bytes_written == data_to_send_size);
+
+ ::FlushFileBuffers(g_write_ack_pipe);
+ ::DisconnectNamedPipe(g_write_ack_pipe);
+
+ if (g_ack_data) {
+ g_ack_data.reset();
+ }
+ }
+}
+
bool ProcessLaunchNotification(
const ProcessSingleton::NotificationCallback& notification_callback,
UINT message,
@@ -167,16 +249,23 @@ bool ProcessLaunchNotification(
// Handle the WM_COPYDATA message from another process. // Handle the WM_COPYDATA message from another process.
const COPYDATASTRUCT* cds = reinterpret_cast<COPYDATASTRUCT*>(lparam); const COPYDATASTRUCT* cds = reinterpret_cast<COPYDATASTRUCT*>(lparam);
@ -240,39 +415,116 @@ index 679350dd08ca0211653ea669405e3f4f86c2fc0f..daab2f170d857082df56966c7bd8abc5
base::FilePath current_directory; base::FilePath current_directory;
- if (!ParseCommandLine(cds, &parsed_command_line, &current_directory)) { - if (!ParseCommandLine(cds, &parsed_command_line, &current_directory)) {
+ std::vector<const uint8_t> additional_data; + std::vector<const uint8_t> additional_data;
+ if (!ParseCommandLine(cds, &parsed_command_line, &current_directory, &additional_data)) { + if (!ParseCommandLine(cds, &parsed_command_line, &current_directory,
+ &additional_data)) {
*result = TRUE; *result = TRUE;
return true; return true;
} }
- *result = notification_callback.Run(parsed_command_line, current_directory) ? - *result = notification_callback.Run(parsed_command_line, current_directory) ?
- TRUE : FALSE; - TRUE : FALSE;
+ *result = notification_callback.Run(parsed_command_line, + g_write_ack_callback_called = false;
+ current_directory, std::move(additional_data)) ? TRUE : FALSE; + *result = notification_callback.Run(parsed_command_line, current_directory,
+ std::move(additional_data),
+ base::BindRepeating(&StoreAck))
+ ? TRUE
+ : FALSE;
+ g_ack_timer.Start(FROM_HERE, base::Seconds(0),
+ base::BindOnce(&SendBackAck));
return true; return true;
} }
@@ -273,9 +306,11 @@ bool ProcessSingleton::EscapeVirtualization( @@ -273,9 +362,13 @@ bool ProcessSingleton::EscapeVirtualization(
ProcessSingleton::ProcessSingleton( ProcessSingleton::ProcessSingleton(
const std::string& program_name, const std::string& program_name,
const base::FilePath& user_data_dir, const base::FilePath& user_data_dir,
+ const base::span<const uint8_t> additional_data, + const base::span<const uint8_t> additional_data,
bool is_app_sandboxed, bool is_app_sandboxed,
const NotificationCallback& notification_callback) - const NotificationCallback& notification_callback)
+ const NotificationCallback& notification_callback,
+ const NotificationAckCallback& notification_ack_callback)
: notification_callback_(notification_callback), : notification_callback_(notification_callback),
+ notification_ack_callback_(notification_ack_callback),
+ additional_data_(additional_data), + additional_data_(additional_data),
program_name_(program_name), program_name_(program_name),
is_app_sandboxed_(is_app_sandboxed), is_app_sandboxed_(is_app_sandboxed),
is_virtualized_(false), is_virtualized_(false),
@@ -300,7 +335,7 @@ ProcessSingleton::NotifyResult ProcessSingleton::NotifyOtherProcess() { @@ -290,6 +383,37 @@ ProcessSingleton::~ProcessSingleton() {
::CloseHandle(lock_file_);
}
+void ReadAck(const ProcessSingleton::NotificationAckCallback& ack_callback) {
+ // We are reading the ack from the first instance.
+ // First, wait for the pipe.
+ ::WaitNamedPipe(kPipeName, NMPWAIT_USE_DEFAULT_WAIT);
+
+ HANDLE read_ack_pipe = ::CreateFile(kPipeName,
+ GENERIC_READ,
+ FILE_SHARE_READ,
+ NULL,
+ OPEN_EXISTING,
+ FILE_ATTRIBUTE_NORMAL,
+ NULL);
+ CHECK(read_ack_pipe != INVALID_HANDLE_VALUE);
+
+ DWORD bytes_read;
+ uint8_t read_ack_buffer[kMaxMessageLength];
+ ::ReadFile(read_ack_pipe,
+ (LPVOID)read_ack_buffer,
+ kMaxMessageLength,
+ &bytes_read,
+ NULL);
+
+ if (!bytes_read) {
+ ack_callback.Run(nullptr);
+ } else {
+ base::span<const uint8_t> out_span(read_ack_buffer, read_ack_buffer + bytes_read);
+ ack_callback.Run(&out_span);
+ }
+ ::CloseHandle(read_ack_pipe);
+}
+
// Code roughly based on Mozilla.
ProcessSingleton::NotifyResult ProcessSingleton::NotifyOtherProcess() {
if (is_virtualized_)
@@ -300,8 +424,9 @@ ProcessSingleton::NotifyResult ProcessSingleton::NotifyOtherProcess() {
return PROCESS_NONE; return PROCESS_NONE;
} }
- switch (chrome::AttemptToNotifyRunningChrome(remote_window_)) { - switch (chrome::AttemptToNotifyRunningChrome(remote_window_)) {
+ switch (chrome::AttemptToNotifyRunningChrome(remote_window_, additional_data_)) { + switch (chrome::AttemptToNotifyRunningChrome(remote_window_, additional_data_)) {
case chrome::NOTIFY_SUCCESS: case chrome::NOTIFY_SUCCESS:
+ ReadAck(notification_ack_callback_);
return PROCESS_NOTIFIED; return PROCESS_NOTIFIED;
case chrome::NOTIFY_FAILED: case chrome::NOTIFY_FAILED:
remote_window_ = NULL;
@@ -431,6 +556,18 @@ bool ProcessSingleton::Create() {
<< "Lock file can not be created! Error code: " << error;
if (lock_file_ != INVALID_HANDLE_VALUE) {
+ // We are the first instance. Create a pipe to send out ack data.
+ ack_pipe_ = ::CreateNamedPipe(kPipeName,
+ PIPE_ACCESS_OUTBOUND,
+ PIPE_TYPE_BYTE | PIPE_REJECT_REMOTE_CLIENTS,
+ PIPE_UNLIMITED_INSTANCES,
+ kMaxMessageLength,
+ 0,
+ kPipeTimeout,
+ NULL);
+ CHECK(ack_pipe_ != INVALID_HANDLE_VALUE);
+ g_write_ack_pipe = ack_pipe_;
+
// Set the window's title to the path of our user data directory so
// other Chrome instances can decide if they should forward to us.
bool result =
@@ -457,6 +594,7 @@ bool ProcessSingleton::Create() {
}
void ProcessSingleton::Cleanup() {
+ ::CloseHandle(ack_pipe_);
}
void ProcessSingleton::OverrideShouldKillRemoteProcessCallbackForTesting(
diff --git a/chrome/browser/win/chrome_process_finder.cc b/chrome/browser/win/chrome_process_finder.cc diff --git a/chrome/browser/win/chrome_process_finder.cc b/chrome/browser/win/chrome_process_finder.cc
index b4fec8878c37b9d157ea768e3b6d99399a988c75..e1cb0f21f752aaeee2c360ce9c5fd08bfede26e3 100644 index b4fec8878c37b9d157ea768e3b6d99399a988c75..e1cb0f21f752aaeee2c360ce9c5fd08bfede26e3 100644
--- a/chrome/browser/win/chrome_process_finder.cc --- a/chrome/browser/win/chrome_process_finder.cc

70
shell/browser/api/electron_api_app.cc
View file

@ -517,21 +517,24 @@ bool NotificationCallbackWrapper(
const base::RepeatingCallback< const base::RepeatingCallback<
void(const base::CommandLine& command_line, void(const base::CommandLine& command_line,
const base::FilePath& current_directory, const base::FilePath& current_directory,
const std::vector<const uint8_t> additional_data)>& callback, const std::vector<const uint8_t> additional_data,
const ProcessSingleton::NotificationAckCallback& ack_callback)>&
callback,
const base::CommandLine& cmd, const base::CommandLine& cmd,
const base::FilePath& cwd, const base::FilePath& cwd,
const std::vector<const uint8_t> additional_data) { const std::vector<const uint8_t> additional_data,
const ProcessSingleton::NotificationAckCallback& ack_callback) {
// Make sure the callback is called after app gets ready. // Make sure the callback is called after app gets ready.
if (Browser::Get()->is_ready()) { if (Browser::Get()->is_ready()) {
callback.Run(cmd, cwd, std::move(additional_data)); callback.Run(cmd, cwd, std::move(additional_data), ack_callback);
} else { } else {
scoped_refptr<base::SingleThreadTaskRunner> task_runner( scoped_refptr<base::SingleThreadTaskRunner> task_runner(
base::ThreadTaskRunnerHandle::Get()); base::ThreadTaskRunnerHandle::Get());
// Make a copy of the span so that the data isn't lost. // Make a copy of the span so that the data isn't lost.
task_runner->PostTask(FROM_HERE, task_runner->PostTask(
base::BindOnce(base::IgnoreResult(callback), cmd, cwd, FROM_HERE, base::BindOnce(base::IgnoreResult(callback), cmd, cwd,
std::move(additional_data))); std::move(additional_data), ack_callback));
} }
// ProcessSingleton needs to know whether current process is quiting. // ProcessSingleton needs to know whether current process is quiting.
return !Browser::Get()->is_shutting_down(); return !Browser::Get()->is_shutting_down();
@ -1079,15 +1082,54 @@ std::string App::GetLocaleCountryCode() {
return region.size() == 2 ? region : std::string(); return region.size() == 2 ? region : std::string();
} }
void App::OnSecondInstance(const base::CommandLine& cmd, void App::OnFirstInstanceAck(
const base::FilePath& cwd, const base::span<const uint8_t>* first_instance_data) {
const std::vector<const uint8_t> additional_data) { v8::Isolate* isolate = JavascriptEnvironment::GetIsolate();
v8::Locker locker(isolate);
v8::HandleScope handle_scope(isolate);
base::Value data_to_send;
if (first_instance_data) {
// Don't send back the local directly, because it might be empty.
v8::Local<v8::Value> data_local;
data_local = DeserializeV8Value(isolate, *first_instance_data);
if (!data_local.IsEmpty()) {
gin::ConvertFromV8(isolate, data_local, &data_to_send);
}
}
Emit("first-instance-ack", data_to_send);
}
// This function handles the user calling
// the callback parameter sent out by the second-instance event.
static void AckCallbackWrapper(
const ProcessSingleton::NotificationAckCallback& ack_callback,
gin::Arguments* args) {
blink::CloneableMessage ack_message;
args->GetNext(&ack_message);
if (!ack_message.encoded_message.empty()) {
ack_callback.Run(&ack_message.encoded_message);
} else {
ack_callback.Run(nullptr);
}
}
void App::OnSecondInstance(
const base::CommandLine& cmd,
const base::FilePath& cwd,
const std::vector<const uint8_t> additional_data,
const ProcessSingleton::NotificationAckCallback& ack_callback) {
v8::Isolate* isolate = JavascriptEnvironment::GetIsolate(); v8::Isolate* isolate = JavascriptEnvironment::GetIsolate();
v8::Locker locker(isolate); v8::Locker locker(isolate);
v8::HandleScope handle_scope(isolate); v8::HandleScope handle_scope(isolate);
v8::Local<v8::Value> data_value = v8::Local<v8::Value> data_value =
DeserializeV8Value(isolate, std::move(additional_data)); DeserializeV8Value(isolate, std::move(additional_data));
Emit("second-instance", cmd.argv(), cwd, data_value); auto cb = base::BindRepeating(&AckCallbackWrapper, ack_callback);
bool prevent_default =
Emit("second-instance", cmd.argv(), cwd, data_value, cb);
if (!prevent_default) {
// Call the callback ourselves, and send back nothing.
ack_callback.Run(nullptr);
}
} }
bool App::HasSingleInstanceLock() const { bool App::HasSingleInstanceLock() const {
@ -1106,6 +1148,9 @@ bool App::RequestSingleInstanceLock(gin::Arguments* args) {
base::PathService::Get(chrome::DIR_USER_DATA, &user_dir); base::PathService::Get(chrome::DIR_USER_DATA, &user_dir);
auto cb = base::BindRepeating(&App::OnSecondInstance, base::Unretained(this)); auto cb = base::BindRepeating(&App::OnSecondInstance, base::Unretained(this));
auto wrapped_cb = base::BindRepeating(NotificationCallbackWrapper, cb);
auto ack_cb =
base::BindRepeating(&App::OnFirstInstanceAck, base::Unretained(this));
blink::CloneableMessage additional_data_message; blink::CloneableMessage additional_data_message;
args->GetNext(&additional_data_message); args->GetNext(&additional_data_message);
@ -1114,11 +1159,10 @@ bool App::RequestSingleInstanceLock(gin::Arguments* args) {
IsSandboxEnabled(base::CommandLine::ForCurrentProcess()); IsSandboxEnabled(base::CommandLine::ForCurrentProcess());
process_singleton_ = std::make_unique<ProcessSingleton>( process_singleton_ = std::make_unique<ProcessSingleton>(
program_name, user_dir, additional_data_message.encoded_message, program_name, user_dir, additional_data_message.encoded_message,
app_is_sandboxed, base::BindRepeating(NotificationCallbackWrapper, cb)); app_is_sandboxed, wrapped_cb, ack_cb);
#else #else
process_singleton_ = std::make_unique<ProcessSingleton>( process_singleton_ = std::make_unique<ProcessSingleton>(
user_dir, additional_data_message.encoded_message, user_dir, additional_data_message.encoded_message, wrapped_cb, ack_cb);
base::BindRepeating(NotificationCallbackWrapper, cb));
#endif #endif
switch (process_singleton_->NotifyOtherProcessOrCreate()) { switch (process_singleton_->NotifyOtherProcessOrCreate()) {

9
shell/browser/api/electron_api_app.h
View file

@ -192,9 +192,12 @@ class App : public ElectronBrowserClient::Delegate,
void SetDesktopName(const std::string& desktop_name); void SetDesktopName(const std::string& desktop_name);
std::string GetLocale(); std::string GetLocale();
std::string GetLocaleCountryCode(); std::string GetLocaleCountryCode();
void OnSecondInstance(const base::CommandLine& cmd, void OnFirstInstanceAck(const base::span<const uint8_t>* first_instance_data);
const base::FilePath& cwd, void OnSecondInstance(
const std::vector<const uint8_t> additional_data); const base::CommandLine& cmd,
const base::FilePath& cwd,
const std::vector<const uint8_t> additional_data,
const ProcessSingleton::NotificationAckCallback& ack_callback);
bool HasSingleInstanceLock() const; bool HasSingleInstanceLock() const;
bool RequestSingleInstanceLock(gin::Arguments* args); bool RequestSingleInstanceLock(gin::Arguments* args);
void ReleaseSingleInstanceLock(); void ReleaseSingleInstanceLock();

114
spec-main/api-app-spec.ts
View file

@ -208,18 +208,23 @@ describe('app module', () => {
interface SingleInstanceLockTestArgs { interface SingleInstanceLockTestArgs {
args: string[]; args: string[];
expectedAdditionalData: unknown; expectedAdditionalData: unknown;
expectedAck: unknown;
} }
it('prevents the second launch of app', async function () { it('prevents the second launch of app', async function () {
this.timeout(120000); this.timeout(60000);
const appPath = path.join(fixturesPath, 'api', 'singleton-data'); const appPath = path.join(fixturesPath, 'api', 'singleton');
const first = cp.spawn(process.execPath, [appPath]); const first = cp.spawn(process.execPath, [appPath]);
const firstExited = emittedOnce(first, 'exit');
await emittedOnce(first.stdout, 'data'); await emittedOnce(first.stdout, 'data');
// Start second app when received output. // Start second app when received output.
const second = cp.spawn(process.execPath, [appPath]); const second = cp.spawn(process.execPath, [appPath]);
const [code2] = await emittedOnce(second, 'exit'); const secondExited = emittedOnce(second, 'exit');
const [code2] = await secondExited;
expect(code2).to.equal(1); expect(code2).to.equal(1);
const [code1] = await emittedOnce(first, 'exit'); const [code1] = await firstExited;
expect(code1).to.equal(0); expect(code1).to.equal(0);
}); });
@ -238,6 +243,11 @@ describe('app module', () => {
const secondInstanceArgs = [process.execPath, appPath, ...testArgs.args, '--some-switch', 'some-arg']; const secondInstanceArgs = [process.execPath, appPath, ...testArgs.args, '--some-switch', 'some-arg'];
const second = cp.spawn(secondInstanceArgs[0], secondInstanceArgs.slice(1)); const second = cp.spawn(secondInstanceArgs[0], secondInstanceArgs.slice(1));
const secondExited = emittedOnce(second, 'exit'); const secondExited = emittedOnce(second, 'exit');
const secondStdoutLines = second.stdout.pipe(split());
let ackData;
while ((ackData = await emittedOnce(secondStdoutLines, 'data'))[0].toString().length === 0) {
// This isn't valid data.
}
const [code2] = await secondExited; const [code2] = await secondExited;
expect(code2).to.equal(1); expect(code2).to.equal(1);
@ -247,6 +257,7 @@ describe('app module', () => {
const [args, additionalData] = dataFromSecondInstance[0].toString('ascii').split('||'); const [args, additionalData] = dataFromSecondInstance[0].toString('ascii').split('||');
const secondInstanceArgsReceived: string[] = JSON.parse(args.toString('ascii')); const secondInstanceArgsReceived: string[] = JSON.parse(args.toString('ascii'));
const secondInstanceDataReceived = JSON.parse(additionalData.toString('ascii')); const secondInstanceDataReceived = JSON.parse(additionalData.toString('ascii'));
const dataAckReceived = JSON.parse(ackData[0].toString('ascii'));
// Ensure secondInstanceArgs is a subset of secondInstanceArgsReceived // Ensure secondInstanceArgs is a subset of secondInstanceArgsReceived
for (const arg of secondInstanceArgs) { for (const arg of secondInstanceArgs) {
@ -255,69 +266,113 @@ describe('app module', () => {
} }
expect(secondInstanceDataReceived).to.be.deep.equal(testArgs.expectedAdditionalData, expect(secondInstanceDataReceived).to.be.deep.equal(testArgs.expectedAdditionalData,
`received data ${JSON.stringify(secondInstanceDataReceived)} is not equal to expected data ${JSON.stringify(testArgs.expectedAdditionalData)}.`); `received data ${JSON.stringify(secondInstanceDataReceived)} is not equal to expected data ${JSON.stringify(testArgs.expectedAdditionalData)}.`);
expect(dataAckReceived).to.be.deep.equal(testArgs.expectedAck,
`received data ${JSON.stringify(dataAckReceived)} is not equal to expected data ${JSON.stringify(testArgs.expectedAck)}.`);
} }
it('passes arguments to the second-instance event no additional data', async () => { const expectedAdditionalData = {
level: 1,
testkey: 'testvalue1',
inner: {
level: 2,
testkey: 'testvalue2'
}
};
const expectedAck = {
level: 1,
testkey: 'acktestvalue1',
inner: {
level: 2,
testkey: 'acktestvalue2'
}
};
it('passes arguments to the second-instance event with no additional data', async () => {
await testArgumentPassing({ await testArgumentPassing({
args: [], args: [],
expectedAdditionalData: null expectedAdditionalData: null,
expectedAck: null
}); });
}); });
it('sends and receives JSON object data', async () => { it('passes arguments to the second-instance event', async () => {
const expectedAdditionalData = {
level: 1,
testkey: 'testvalue1',
inner: {
level: 2,
testkey: 'testvalue2'
}
};
await testArgumentPassing({ await testArgumentPassing({
args: ['--send-data'], args: ['--send-data'],
expectedAdditionalData expectedAdditionalData,
expectedAck: null
});
});
it('gets back an ack after preventing default', async () => {
await testArgumentPassing({
args: ['--send-ack', '--prevent-default'],
expectedAdditionalData: null,
expectedAck
});
});
it('is able to send back empty ack after preventing default', async () => {
await testArgumentPassing({
args: ['--prevent-default'],
expectedAdditionalData: null,
expectedAck: null
});
});
it('sends and receives data', async () => {
await testArgumentPassing({
args: ['--send-ack', '--prevent-default', '--send-data'],
expectedAdditionalData,
expectedAck
}); });
}); });
it('sends and receives numerical data', async () => { it('sends and receives numerical data', async () => {
await testArgumentPassing({ await testArgumentPassing({
args: ['--send-data', '--data-content=2'], args: ['--send-ack', '--ack-content=1', '--prevent-default', '--send-data', '--data-content=2'],
expectedAdditionalData: 2 expectedAdditionalData: 2,
expectedAck: 1
}); });
}); });
it('sends and receives string data', async () => { it('sends and receives string data', async () => {
await testArgumentPassing({ await testArgumentPassing({
args: ['--send-data', '--data-content="data"'], args: ['--send-ack', '--ack-content="ack"', '--prevent-default', '--send-data', '--data-content="data"'],
expectedAdditionalData: 'data' expectedAdditionalData: 'data',
expectedAck: 'ack'
}); });
}); });
it('sends and receives boolean data', async () => { it('sends and receives boolean data', async () => {
await testArgumentPassing({ await testArgumentPassing({
args: ['--send-data', '--data-content=false'], args: ['--send-ack', '--ack-content=true', '--prevent-default', '--send-data', '--data-content=false'],
expectedAdditionalData: false expectedAdditionalData: false,
expectedAck: true
}); });
}); });
it('sends and receives array data', async () => { it('sends and receives array data', async () => {
await testArgumentPassing({ await testArgumentPassing({
args: ['--send-data', '--data-content=[2, 3, 4]'], args: ['--send-ack', '--ack-content=[1, 2, 3]', '--prevent-default', '--send-data', '--data-content=[2, 3, 4]'],
expectedAdditionalData: [2, 3, 4] expectedAdditionalData: [2, 3, 4],
expectedAck: [1, 2, 3]
}); });
}); });
it('sends and receives mixed array data', async () => { it('sends and receives mixed array data', async () => {
await testArgumentPassing({ await testArgumentPassing({
args: ['--send-data', '--data-content=["2", true, 4]'], args: ['--send-ack', '--ack-content=["1", true, 3]', '--prevent-default', '--send-data', '--data-content=["2", false, 4]'],
expectedAdditionalData: ['2', true, 4] expectedAdditionalData: ['2', false, 4],
expectedAck: ['1', true, 3]
}); });
}); });
it('sends and receives null data', async () => { it('sends and receives null data', async () => {
await testArgumentPassing({ await testArgumentPassing({
args: ['--send-data', '--data-content=null'], args: ['--send-ack', '--ack-content=null', '--prevent-default', '--send-data', '--data-content=null'],
expectedAdditionalData: null expectedAdditionalData: null,
expectedAck: null
}); });
}); });
@ -325,7 +380,8 @@ describe('app module', () => {
try { try {
await testArgumentPassing({ await testArgumentPassing({
args: ['--send-ack', '--ack-content="undefined"', '--prevent-default', '--send-data', '--data-content="undefined"'], args: ['--send-ack', '--ack-content="undefined"', '--prevent-default', '--send-data', '--data-content="undefined"'],
expectedAdditionalData: undefined expectedAdditionalData: undefined,
expectedAck: undefined
}); });
assert(false); assert(false);
} catch (e) { } catch (e) {

41
spec/fixtures/api/singleton-data/main.js vendored
View file

@ -1,12 +1,18 @@
const { app } = require('electron'); const { app } = require('electron');
// Send data from the second instance to the first instance.
const sendAdditionalData = app.commandLine.hasSwitch('send-data');
app.whenReady().then(() => { app.whenReady().then(() => {
console.log('started'); // ping parent console.log('started'); // ping parent
}); });
// Send data from the second instance to the first instance.
const sendAdditionalData = app.commandLine.hasSwitch('send-data');
// Prevent the default behaviour of second-instance, which sends back an empty ack.
const preventDefault = app.commandLine.hasSwitch('prevent-default');
// Send an object back for the ack rather than undefined.
const sendAck = app.commandLine.hasSwitch('send-ack');
let obj = { let obj = {
level: 1, level: 1,
testkey: 'testvalue1', testkey: 'testvalue1',
@ -15,20 +21,45 @@ let obj = {
testkey: 'testvalue2' testkey: 'testvalue2'
} }
}; };
let ackObj = {
level: 1,
testkey: 'acktestvalue1',
inner: {
level: 2,
testkey: 'acktestvalue2'
}
};
if (app.commandLine.hasSwitch('data-content')) { if (app.commandLine.hasSwitch('data-content')) {
obj = JSON.parse(app.commandLine.getSwitchValue('data-content')); obj = JSON.parse(app.commandLine.getSwitchValue('data-content'));
if (obj === 'undefined') { if (obj === 'undefined') {
obj = undefined; obj = undefined;
} }
} }
if (app.commandLine.hasSwitch('ack-content')) {
ackObj = JSON.parse(app.commandLine.getSwitchValue('ack-content'));
if (ackObj === 'undefined') {
ackObj = undefined;
}
}
app.on('first-instance-ack', (event, additionalData) => {
console.log(JSON.stringify(additionalData));
});
const gotTheLock = sendAdditionalData const gotTheLock = sendAdditionalData
? app.requestSingleInstanceLock(obj) : app.requestSingleInstanceLock(); ? app.requestSingleInstanceLock(obj) : app.requestSingleInstanceLock();
app.on('second-instance', (event, args, workingDirectory, data) => { app.on('second-instance', (event, args, workingDirectory, data, ackCallback) => {
if (preventDefault) {
event.preventDefault();
}
setImmediate(() => { setImmediate(() => {
console.log([JSON.stringify(args), JSON.stringify(data)].join('||')); console.log([JSON.stringify(args), JSON.stringify(data)].join('||'));
app.exit(0); sendAck ? ackCallback(ackObj) : ackCallback();
setImmediate(() => {
app.exit(0);
});
}); });
}); });