From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 From: Raymond Zhao Date: Tue, 7 Sep 2021 14:54:25 -0700 Subject: feat: Add data transfer mechanism to requestSingleInstanceLock flow This patch adds code that allows for the second instance to send additional data to the first instance, and for the first instance to send additional data back to the second instance, during the app.requestSingleInstanceLock call. Firstly, this patch adds an additional_data parameter to the constructor of ProcessSingleton, so that the second 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 index 5a64220aaf1309832dc0ad543e353de67fe0a779..5b701b1361707b610ed60c344e441e67ca701362 100644 --- a/chrome/browser/process_singleton.h +++ b/chrome/browser/process_singleton.h @@ -18,6 +18,7 @@ #include "base/files/file_path.h" #include "base/memory/ref_counted.h" #include "base/process/process.h" +#include "base/containers/span.h" #include "ui/gfx/native_widget_types.h" #if BUILDFLAG(IS_POSIX) && !BUILDFLAG(IS_ANDROID) @@ -93,6 +94,9 @@ class ProcessSingleton { static constexpr int kNumNotifyResults = LAST_VALUE + 1; + using NotificationAckCallback = + base::RepeatingCallback* 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). using NotificationCallback = base::RepeatingCallback; + const base::FilePath& current_directory, + const std::vector additional_data, + const NotificationAckCallback& ack_callback)>; #if BUILDFLAG(IS_WIN) ProcessSingleton(const std::string& program_name, const base::FilePath& user_data_dir, + const base::span additional_data, bool is_sandboxed, - const NotificationCallback& notification_callback); + const NotificationCallback& notification_callback, + const NotificationAckCallback& ack_notification_callback); #else ProcessSingleton(const base::FilePath& user_data_dir, - const NotificationCallback& notification_callback); + const base::span additional_data, + const NotificationCallback& notification_callback, + const NotificationAckCallback& ack_notification_callback); +#endif ProcessSingleton(const ProcessSingleton&) = delete; ProcessSingleton& operator=(const ProcessSingleton&) = delete; -#endif ~ProcessSingleton(); // Notify another process, if available. Otherwise sets ourselves as the @@ -177,7 +187,13 @@ class ProcessSingleton { #endif private: - 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. + base::span additional_data_; #if BUILDFLAG(IS_WIN) 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 BUILDFLAG(IS_POSIX) && !BUILDFLAG(IS_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 index 7d3a441bdb64268ed5fbfa7bf589fb35a2fd1b75..44d563e35efb318c5684c30fc441996a5a1f1424 100644 --- a/chrome/browser/process_singleton_posix.cc +++ b/chrome/browser/process_singleton_posix.cc @@ -148,7 +148,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; @@ -614,6 +614,7 @@ class ProcessSingleton::LinuxWatcher // |reader| is for sending back ACK message. void HandleMessage(const std::string& current_dir, const std::vector& argv, + const std::vector additional_data, SocketReader* reader); private: @@ -638,6 +639,9 @@ class ProcessSingleton::LinuxWatcher // The ProcessSingleton that owns us. ProcessSingleton* const parent_; + bool ack_callback_called_ = false; + void AckCallback(SocketReader* reader, const base::span* response); + std::set, base::UniquePtrComparator> readers_; }; @@ -668,16 +672,21 @@ void ProcessSingleton::LinuxWatcher::StartListening(int socket) { } void ProcessSingleton::LinuxWatcher::HandleMessage( - const std::string& current_dir, const std::vector& argv, + const std::string& current_dir, + const std::vector& argv, + const std::vector additional_data, SocketReader* reader) { DCHECK(ui_task_runner_->BelongsToCurrentThread()); DCHECK(reader); - if (parent_->notification_callback_.Run(base::CommandLine(argv), - 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), + std::move(additional_data), + wrapped_ack_callback)) { LOG(WARNING) << "Not handling interprocess notification as browser" " is shutting down"; // Send back "SHUTDOWN" message, so that the client process can start up @@ -687,6 +696,22 @@ void ProcessSingleton::LinuxWatcher::HandleMessage( } } +void ProcessSingleton::LinuxWatcher::AckCallback( + SocketReader* reader, + const base::span* 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(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); @@ -722,7 +747,8 @@ void ProcessSingleton::LinuxWatcher::SocketReader:: } } - // Validate the message. The shortest message is kStartToken\0x\0x + // Validate the message. The shortest message kStartToken\0\00 + // The shortest message with additional data is kStartToken\0\00\00\0. const size_t kMinMessageLength = base::size(kStartToken) + 4; if (bytes_read_ < kMinMessageLength) { buf_[bytes_read_] = 0; @@ -752,10 +778,28 @@ void ProcessSingleton::LinuxWatcher::SocketReader:: tokens.erase(tokens.begin()); tokens.erase(tokens.begin()); + size_t num_args; + base::StringToSizeT(tokens[0], &num_args); + std::vector command_line(tokens.begin() + 1, tokens.begin() + 1 + num_args); + + std::vector additional_data; + if (tokens.size() >= 3 + num_args) { + size_t additional_data_size; + base::StringToSizeT(tokens[1 + num_args], &additional_data_size); + std::string remaining_args = base::JoinString( + base::make_span(tokens.begin() + 2 + num_args, tokens.end()), + std::string(1, kTokenDelimiter)); + const uint8_t* additional_data_bits = + reinterpret_cast(remaining_args.c_str()); + additional_data = std::vector(additional_data_bits, + additional_data_bits + additional_data_size); + } + // Return to the UI thread to handle opening a new browser tab. ui_task_runner_->PostTask( FROM_HERE, base::BindOnce(&ProcessSingleton::LinuxWatcher::HandleMessage, - parent_, current_dir, tokens, this)); + parent_, current_dir, command_line, + std::move(additional_data), this)); fd_watch_controller_.reset(); // LinuxWatcher::HandleMessage() is in charge of destroying this SocketReader @@ -784,8 +828,12 @@ void ProcessSingleton::LinuxWatcher::SocketReader::FinishWithACK( // ProcessSingleton::ProcessSingleton( const base::FilePath& user_data_dir, - const NotificationCallback& notification_callback) + const base::span additional_data, + const NotificationCallback& notification_callback, + const NotificationAckCallback& notification_ack_callback) : notification_callback_(notification_callback), + notification_ack_callback_(notification_ack_callback), + additional_data_(additional_data), current_pid_(base::GetCurrentProcId()), watcher_(new LinuxWatcher(this)) { socket_path_ = user_data_dir.Append(chrome::kSingletonSocketFilename); @@ -904,7 +952,8 @@ ProcessSingleton::NotifyResult ProcessSingleton::NotifyOtherProcessWithTimeout( sizeof(socket_timeout)); // Found another process, prepare our command line - // format is "START\0\0\0...\0". + // format is "START\0\0\0\0...\0 + // \0\0". std::string to_send(kStartToken); to_send.push_back(kTokenDelimiter); @@ -914,11 +963,21 @@ ProcessSingleton::NotifyResult ProcessSingleton::NotifyOtherProcessWithTimeout( to_send.append(current_dir.value()); const std::vector& argv = cmd_line.argv(); + to_send.push_back(kTokenDelimiter); + to_send.append(base::NumberToString(argv.size())); for (auto it = argv.begin(); it != argv.end(); ++it) { to_send.push_back(kTokenDelimiter); to_send.append(*it); } + size_t data_to_send_size = additional_data_.size_bytes(); + if (data_to_send_size) { + to_send.push_back(kTokenDelimiter); + to_send.append(base::NumberToString(data_to_send_size)); + to_send.push_back(kTokenDelimiter); + to_send.append(reinterpret_cast(additional_data_.data()), data_to_send_size); + } + // Send the message if (!WriteToSocket(socket.fd(), to_send.data(), to_send.length())) { // Try to kill the other process, because it might have been dead. @@ -960,6 +1019,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(buf + base::size(kACKToken) - 1); + base::span 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 index 0ea5eb3e3cf055d981ab73486115bac53287f2d7..1d393e6e161b896a47d3490d902f2ce82ad6abb2 100644 --- a/chrome/browser/process_singleton_win.cc +++ b/chrome/browser/process_singleton_win.cc @@ -21,6 +21,7 @@ #include "base/strings/string_number_conversions.h" #include "base/strings/utf_string_conversions.h" #include "base/time/time.h" +#include "base/timer/timer.h" #include "base/trace_event/base_tracing.h" #include "base/win/registry.h" #include "base/win/scoped_handle.h" @@ -45,6 +46,14 @@ namespace { const char kLockfile[] = "lockfile"; +const LPCWSTR kPipeName = L"\\\\.\\pipe\\electronAckPipe"; +const DWORD kPipeTimeout = 10000; +const DWORD kMaxMessageLength = 32 * 1024; + +std::unique_ptr> 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. @@ -80,10 +89,12 @@ BOOL CALLBACK BrowserWindowEnumeration(HWND window, LPARAM param) { bool ParseCommandLine(const COPYDATASTRUCT* cds, base::CommandLine* parsed_command_line, - base::FilePath* current_directory) { + base::FilePath* current_directory, + std::vector* parsed_additional_data) { // We should have enough room for the shortest command (min_message_size) // and also be a multiple of wchar_t bytes. The shortest command - // possible is L"START\0\0" (empty current directory and command line). + // possible is L"START\0\0" (empty command line, current directory, + // and additional data). static const int min_message_size = 7; if (cds->cbData < min_message_size * sizeof(wchar_t) || cds->cbData % sizeof(wchar_t) != 0) { @@ -133,11 +144,82 @@ bool ParseCommandLine(const COPYDATASTRUCT* cds, const std::wstring cmd_line = msg.substr(second_null + 1, third_null - second_null); *parsed_command_line = base::CommandLine::FromString(cmd_line); + + const std::wstring::size_type fourth_null = + msg.find_first_of(L'\0', third_null + 1); + if (fourth_null == std::wstring::npos || + fourth_null == msg.length()) { + // No additional data was provided. + return true; + } + + // Get length of the additional data. + const std::wstring additional_data_length_string = + msg.substr(third_null + 1, fourth_null - third_null); + size_t additional_data_length; + base::StringToSizeT(additional_data_length_string, &additional_data_length); + + const std::wstring::size_type fifth_null = + msg.find_first_of(L'\0', fourth_null + 1); + if (fifth_null == std::wstring::npos || + fifth_null == msg.length()) { + LOG(WARNING) << "Invalid format for start command, we need a string in 6 " + "parts separated by NULLs"; + } + + // Get the actual additional data. + const std::wstring additional_data = + msg.substr(fourth_null + 1, fifth_null - fourth_null); + const uint8_t* additional_data_bytes = + reinterpret_cast(additional_data.c_str()); + *parsed_additional_data = std::vector(additional_data_bytes, + additional_data_bytes + additional_data_length); + return true; } return false; } +void StoreAck(const base::span* ack_data) { + if (ack_data) { + g_ack_data = std::make_unique>(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, @@ -151,16 +233,23 @@ bool ProcessLaunchNotification( // Handle the WM_COPYDATA message from another process. const COPYDATASTRUCT* cds = reinterpret_cast(lparam); - base::CommandLine parsed_command_line(base::CommandLine::NO_PROGRAM); base::FilePath current_directory; - if (!ParseCommandLine(cds, &parsed_command_line, ¤t_directory)) { + std::vector additional_data; + if (!ParseCommandLine(cds, &parsed_command_line, ¤t_directory, + &additional_data)) { *result = TRUE; return true; } - *result = notification_callback.Run(parsed_command_line, current_directory) ? - TRUE : FALSE; + g_write_ack_callback_called = 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; } @@ -254,9 +343,13 @@ bool ProcessSingleton::EscapeVirtualization( ProcessSingleton::ProcessSingleton( const std::string& program_name, const base::FilePath& user_data_dir, + const base::span additional_data, bool is_app_sandboxed, - const NotificationCallback& notification_callback) + const NotificationCallback& notification_callback, + const NotificationAckCallback& notification_ack_callback) : notification_callback_(notification_callback), + notification_ack_callback_(notification_ack_callback), + additional_data_(additional_data), program_name_(program_name), is_app_sandboxed_(is_app_sandboxed), is_virtualized_(false), @@ -271,6 +364,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 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() { TRACE_EVENT0("startup", "ProcessSingleton::NotifyOtherProcess"); @@ -283,8 +407,9 @@ ProcessSingleton::NotifyResult ProcessSingleton::NotifyOtherProcess() { return PROCESS_NONE; } - switch (chrome::AttemptToNotifyRunningChrome(remote_window_)) { + switch (chrome::AttemptToNotifyRunningChrome(remote_window_, additional_data_)) { case chrome::NOTIFY_SUCCESS: + ReadAck(notification_ack_callback_); return PROCESS_NOTIFIED; case chrome::NOTIFY_FAILED: remote_window_ = NULL; @@ -422,6 +547,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. TRACE_EVENT0("startup", "ProcessSingleton::Create:CreateWindow"); @@ -449,6 +586,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 index b64ed1d155a30582e48c9cdffcee9d0f25a53a6a..ce851d09d501ebcc6d6c4065e746e869d5275b2b 100644 --- a/chrome/browser/win/chrome_process_finder.cc +++ b/chrome/browser/win/chrome_process_finder.cc @@ -36,9 +36,10 @@ HWND FindRunningChromeWindow(const base::FilePath& user_data_dir) { return base::win::MessageWindow::FindWindow(user_data_dir.value()); } -NotifyChromeResult AttemptToNotifyRunningChrome(HWND remote_window) { +NotifyChromeResult AttemptToNotifyRunningChrome( + HWND remote_window, + const base::span additional_data) { TRACE_EVENT0("startup", "AttemptToNotifyRunningChrome"); - DCHECK(remote_window); DWORD process_id = 0; DWORD thread_id = GetWindowThreadProcessId(remote_window, &process_id); @@ -50,7 +51,8 @@ NotifyChromeResult AttemptToNotifyRunningChrome(HWND remote_window) { } // Send the command line to the remote chrome window. - // Format is "START\0<<>>\0<<>>". + // Format is + // "START\0\0\0\0". std::wstring to_send(L"START\0", 6); // want the NULL in the string. base::FilePath cur_dir; if (!base::GetCurrentDirectory(&cur_dir)) { @@ -64,6 +66,22 @@ NotifyChromeResult AttemptToNotifyRunningChrome(HWND remote_window) { base::CommandLine::ForCurrentProcess()->GetCommandLineString()); to_send.append(L"\0", 1); // Null separator. + size_t additional_data_size = additional_data.size_bytes(); + if (additional_data_size) { + // Send over the size, because the reinterpret cast to wchar_t could + // add padding. + to_send.append(base::UTF8ToWide(base::NumberToString(additional_data_size))); + to_send.append(L"\0", 1); // Null separator. + + size_t padded_size = additional_data_size / sizeof(wchar_t); + if (additional_data_size % sizeof(wchar_t) != 0) { + padded_size++; + } + to_send.append(reinterpret_cast(additional_data.data()), + padded_size); + to_send.append(L"\0", 1); // Null separator. + } + // Allow the current running browser window to make itself the foreground // window (otherwise it will just flash in the taskbar). ::AllowSetForegroundWindow(process_id); diff --git a/chrome/browser/win/chrome_process_finder.h b/chrome/browser/win/chrome_process_finder.h index 5516673cee019f6060077091e59498bf9038cd6e..8edea5079b46c2cba67833114eb9c21d85cfc22d 100644 --- a/chrome/browser/win/chrome_process_finder.h +++ b/chrome/browser/win/chrome_process_finder.h @@ -7,6 +7,7 @@ #include +#include "base/containers/span.h" #include "base/time/time.h" namespace base { @@ -27,7 +28,9 @@ HWND FindRunningChromeWindow(const base::FilePath& user_data_dir); // Attempts to send the current command line to an already running instance of // Chrome via a WM_COPYDATA message. // Returns true if a running Chrome is found and successfully notified. -NotifyChromeResult AttemptToNotifyRunningChrome(HWND remote_window); +NotifyChromeResult AttemptToNotifyRunningChrome( + HWND remote_window, + const base::span additional_data); // Changes the notification timeout to |new_timeout|, returns the old timeout. base::TimeDelta SetNotificationTimeoutForTesting(base::TimeDelta new_timeout);