chrome/browser/ash/crosapi/browser_launcher.h - chromium/src - Git at Google

 // Copyright 2023 The Chromium Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 #ifndef CHROME_BROWSER_ASH_CROSAPI_BROWSER_LAUNCHER_H_
 #define CHROME_BROWSER_ASH_CROSAPI_BROWSER_LAUNCHER_H_

 #include <optional>
 #include <string>
 #include <string_view>
 #include <vector>

 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/files/scoped_file.h"
 #include "base/functional/callback_forward.h"
 #include "base/memory/weak_ptr.h"
 #include "base/process/process.h"
 #include "base/time/time.h"
 #include "base/types/expected.h"
 #include "chrome/browser/ash/crosapi/crosapi_id.h"
 #include "chromeos/ash/components/standalone_browser/lacros_selection.h"
 #include "components/nacl/common/buildflags.h"
 #include "components/policy/core/common/values_util.h"
 #include "mojo/public/cpp/platform/platform_channel.h"

 namespace base {
 struct LaunchOptions;
 }  // namespace base

 namespace user_manager {
 class DeviceOwnershipWaiter;
 }  // namespace user_manager

 namespace crosapi {
 class PrimaryProfileCreationWaiter;

 // Manages launching and terminating Lacros process.
 // TODO(crbug.com/40286595): Extract launching logic from BrowserManager to
 // BrowserLauncher.
 class BrowserLauncher {
  public:
   BrowserLauncher();

   BrowserLauncher(const BrowserLauncher&) = delete;
   BrowserLauncher& operator=(const BrowserLauncher&) = delete;

   ~BrowserLauncher();

   // Returns files to preload on launching at login screen.
   static std::vector<base::FilePath> GetPreloadFiles(
       const base::FilePath& lacros_dir);

   // Parameters used to launch Lacros that are calculated on a background
   // sequence.
   struct LaunchParamsFromBackground {
    public:
     LaunchParamsFromBackground();
     LaunchParamsFromBackground(LaunchParamsFromBackground&&);
     LaunchParamsFromBackground& operator=(LaunchParamsFromBackground&&);
     LaunchParamsFromBackground(const LaunchParamsFromBackground&) = delete;
     LaunchParamsFromBackground& operator=(const LaunchParamsFromBackground&) =
         delete;
     ~LaunchParamsFromBackground();

     // An fd for a log file.
     base::ScopedFD logfd;

     // Sets true if Lacros uses resource file sharing.
     bool enable_resource_file_sharing = false;

     // Any additional args to start lacros with.
     std::vector<std::string> lacros_additional_args;
   };

   // Parameters to handle command line and options used to launching Lacros.
   struct LaunchParams {
    public:
     LaunchParams(base::CommandLine command_line, base::LaunchOptions options);
     LaunchParams(LaunchParams&&);
     LaunchParams& operator=(LaunchParams&&);
     LaunchParams(const LaunchParams&) = delete;
     LaunchParams& operator=(const LaunchParams&) = delete;
     ~LaunchParams();

     base::CommandLine command_line;

     base::LaunchOptions options;
   };

   // Results from `LaunchProcess` and needs to be passed to
   // BrowserManager.
   struct LaunchResults {
    public:
     LaunchResults();
     LaunchResults(LaunchResults&&);
     LaunchResults& operator=(LaunchResults&&);
     LaunchResults(const LaunchResults&) = delete;
     LaunchResults& operator=(const LaunchResults&) = delete;
     ~LaunchResults();

     // ID for the current Crosapi connection.
     // Available only when lacros-chrome is running.
     CrosapiId crosapi_id;

     // Time when the lacros process was launched.
     base::TimeTicks lacros_launch_time;
   };

   // Reason of Lacros not being able to launch.
   enum class LaunchFailureReason {
     // Failed to launch due to unknown error.
     kUnknown,

     // Shutdown is requested from BrowserManager during the process launch.
     kShutdownRequested,
   };

   using LaunchCompletionCallback = base::OnceCallback<void(
       base::expected<LaunchResults, LaunchFailureReason>)>;

   // Launches a process of the given options, which are expected to be Lacros's
   // ones.
   // `Launch` will:
   // 1. Prepare launching on background thread to handle blocking resources.
   // 2. Wait for device owner and primary user if it's launching in the user
   // session.
   // 3. Launch lacros process with the params prepared at Step 1.
   //
   // Following is explanation for Arguments.
   // `chrome_path`: Initializes `command_line`.
   // `launching_at_login_screen`: Whether lacros is launching at login screen.
   // `postlogin_pipe_fd`: Pipe FDs through which Ash and Lacros exchange
   // post-login parameters.
   // `lacros_selection`: Whether "rootfs" or "stateful" lacros is selected.
   // `mojo_disconnection_cb`: Callback function setting up mojo connection.
   // `BrowserManager::OnMojoDisconnected` is called.
   // `is_keep_alive_enabled`: Whether `keep_alive_features` is empty.
   // `callback`: Callback function that will be called on launch process
   // completion.
   void Launch(const base::FilePath& chrome_path,
               bool launching_at_login_screen,
               ash::standalone_browser::LacrosSelection lacros_selection,
               base::OnceClosure mojo_disconnection_cb,
               bool is_keep_alive_enabled,
               LaunchCompletionCallback callback);

   // Writes post login data to the Lacros process, resets `postlogin_pipe_fd`
   // and then executes a callback.
   void ResumeLaunch(
       base::OnceCallback<
           void(base::expected<base::TimeTicks, LaunchFailureReason>)> callback);

   // Returns true if process is valid.
   bool IsProcessValid() const;

   // Triggers termination synchronously if process is running.
   // Does not block the thread because it does not wait for the process
   // termination.
   bool TriggerTerminate(int exit_code) const;

   // Waits for termination of the running process asynchronously during the
   // period given by the `timeout`, then invoke `callback`. On timeout, also
   // tries to terminate the process by sending a signal.
   // TODO(mayukoaiba): On calling this function, even before the termination
   // procedure is completed (i.e. before `callback` is called), IsProcessValid
   // will return false and LaunchProcess tries to create the next process, which
   // may be confusing for callers. We should fix this issue.
   void EnsureProcessTerminated(base::OnceClosure callback,
                                base::TimeDelta timeout);

   // Records Shutdown() request from BrowserManager.
   void Shutdown() { shutdown_requested_ = true; }

   // Returns reference to `process_` for testing.
   const base::Process& GetProcessForTesting() const;

   // Provides public API to call LaunchProcessWithParameters for testing.
   bool LaunchProcessForTesting(const LaunchParams& parameters);

   // Provides public API to call CreateLaunchParamsForTesting for testing.
   LaunchParams CreateLaunchParamsForTesting(
       const base::FilePath& chrome_path,
       const LaunchParamsFromBackground& params,
       bool launching_at_login_screen,
       std::optional<int> startup_fd,
       std::optional<int> read_pipe_fd,
       mojo::PlatformChannel& channel,
       ash::standalone_browser::LacrosSelection lacros_selection);

   // Creates postlogin pipe fd and returns the read fd. This is used to test
   // ResumeLaunch. Note that the reader is on the same process and does not
   // launch testing process.
   base::ScopedFD CreatePostLoginPipeForTesting();

   // Sets up additional flags for unit tests.
   // This function overwrites `command_line` with the desired flags.
   void SetUpAdditionalParametersForTesting(LaunchParamsFromBackground& params,
                                            LaunchParams& parameters) const;

   // Provides public API to call WaitForBackgroundWorkPreLaunch for testing.
   void WaitForBackgroundWorkPreLaunchForTesting(
       const base::FilePath& lacros_dir,
       bool clear_shared_resource_file,
       bool launching_at_login_screen,
       base::OnceClosure callback,
       LaunchParamsFromBackground& params);

   // TODO(crbug.com/40275396): Remove this once we refactored to use the
   // constructor.
   void set_device_ownership_waiter_for_testing(
       std::unique_ptr<user_manager::DeviceOwnershipWaiter>
           device_ownership_waiter);

   // Skips device ownership fetch. Use set_device_ownership_waiter_for_testing()
   // above if possible. Use this method only if your test must set up the
   // behavior before BrowserManager is initialized.
   // TODO(crbug.com/40275396): Remove this and set it from constructor.
   static void SkipDeviceOwnershipWaitForTesting(bool skip);

  private:
   // Waits for the prelaunch work running on background thread. `callback` is
   // called on background work completion and the output result is stored in
   // `params`.
   void WaitForBackgroundWorkPreLaunch(const base::FilePath& lacros_dir,
                                       bool clear_shared_resource_file,
                                       bool launching_at_login_screen,
                                       base::OnceClosure callback,
                                       LaunchParamsFromBackground& params);

   // Waits for the device owner being fetched from `UserManager` or the primary
   // user profile being fully created and then executes a callback. Should NOT
   // be called if Lacros is launching at the login screen since the device owner
   // nor the profile is not available until login.
   void WaitForDeviceOwnerFetchedAndThen(base::OnceClosure callback);
   void WaitForPrimaryProfileAddedAndThen(base::OnceClosure callback);

   // Launches lacros-chrome process after device owner and primary profile
   // become ready.
   void LaunchProcess(const base::FilePath& chrome_path,
                      std::unique_ptr<LaunchParamsFromBackground> params,
                      bool launching_at_login_screen,
                      ash::standalone_browser::LacrosSelection lacros_selection,
                      base::OnceClosure mojo_disconnection_cb,
                      bool is_keep_alive_enabled,
                      LaunchCompletionCallback callback);

   LaunchParams CreateLaunchParams(
       const base::FilePath& chrome_path,
       const LaunchParamsFromBackground& params,
       bool launching_at_login_screen,
       std::optional<int> startup_fd,
       std::optional<int> read_pipe_fd,
       mojo::PlatformChannel& channel,
       ash::standalone_browser::LacrosSelection lacros_selection);

   // Launches a process , which is executed in `LaunchProcess`.
   // This is also used for unittest.
   bool LaunchProcessWithParameters(const LaunchParams& parameters);

   // Writes post login data after waiting for device owner and profile to be
   // ready.
   void WritePostLoginData(
       base::OnceCallback<
           void(base::expected<base::TimeTicks, LaunchFailureReason>)> callback);

   // Process handle for the lacros_chrome process.
   base::Process process_;

   // Pipe FDs through which Ash and Lacros exchange post-login parameters.
   base::ScopedFD postlogin_pipe_fd_;

   // Used to delay an action until the definitive device owner is fetched.
   std::unique_ptr<user_manager::DeviceOwnershipWaiter> device_ownership_waiter_;

   // Used to wait for the primary user profile to be fully created.
   std::unique_ptr<PrimaryProfileCreationWaiter>
       primary_profile_creation_waiter_;

   // Tracks whether Shutdown() has been signalled by ash. This flag ensures any
   // new or existing lacros startup tasks are not executed during shutdown.
   bool shutdown_requested_ = false;

   // True if this is the first time that lacros is being launched from this ash
   // process. This value is used for resource sharing feature where ash deletes
   // cached shared resource file after ash is rebooted. Note that this flag
   // should not be reset on reloading as long as the ash process is not
   // relaunched.
   bool is_first_lacros_launch_ = true;

   // Indicates whether the delegate has been used.
   bool device_ownership_waiter_called_ = false;

   base::WeakPtrFactory<BrowserLauncher> weak_factory_{this};
 };

 }  // namespace crosapi

 #endif  // CHROME_BROWSER_ASH_CROSAPI_BROWSER_LAUNCHER_H_
	// Copyright 2023 The Chromium Authors
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	#ifndef CHROME_BROWSER_ASH_CROSAPI_BROWSER_LAUNCHER_H_
	#define CHROME_BROWSER_ASH_CROSAPI_BROWSER_LAUNCHER_H_

	#include <optional>
	#include <string>
	#include <string_view>
	#include <vector>

	#include "base/command_line.h"
	#include "base/files/file_path.h"
	#include "base/files/scoped_file.h"
	#include "base/functional/callback_forward.h"
	#include "base/memory/weak_ptr.h"
	#include "base/process/process.h"
	#include "base/time/time.h"
	#include "base/types/expected.h"
	#include "chrome/browser/ash/crosapi/crosapi_id.h"
	#include "chromeos/ash/components/standalone_browser/lacros_selection.h"
	#include "components/nacl/common/buildflags.h"
	#include "components/policy/core/common/values_util.h"
	#include "mojo/public/cpp/platform/platform_channel.h"

	namespace base {
	struct LaunchOptions;
	} // namespace base

	namespace user_manager {
	class DeviceOwnershipWaiter;
	} // namespace user_manager

	namespace crosapi {
	class PrimaryProfileCreationWaiter;

	// Manages launching and terminating Lacros process.
	// TODO(crbug.com/40286595): Extract launching logic from BrowserManager to
	// BrowserLauncher.
	class BrowserLauncher {
	public:
	BrowserLauncher();

	BrowserLauncher(const BrowserLauncher&) = delete;
	BrowserLauncher& operator=(const BrowserLauncher&) = delete;

	~BrowserLauncher();

	// Returns files to preload on launching at login screen.
	static std::vector<base::FilePath> GetPreloadFiles(
	const base::FilePath& lacros_dir);

	// Parameters used to launch Lacros that are calculated on a background
	// sequence.
	struct LaunchParamsFromBackground {
	public:
	LaunchParamsFromBackground();
	LaunchParamsFromBackground(LaunchParamsFromBackground&&);
	LaunchParamsFromBackground& operator=(LaunchParamsFromBackground&&);
	LaunchParamsFromBackground(const LaunchParamsFromBackground&) = delete;
	LaunchParamsFromBackground& operator=(const LaunchParamsFromBackground&) =
	delete;
	~LaunchParamsFromBackground();

	// An fd for a log file.
	base::ScopedFD logfd;

	// Sets true if Lacros uses resource file sharing.
	bool enable_resource_file_sharing = false;

	// Any additional args to start lacros with.
	std::vector<std::string> lacros_additional_args;
	};

	// Parameters to handle command line and options used to launching Lacros.
	struct LaunchParams {
	public:
	LaunchParams(base::CommandLine command_line, base::LaunchOptions options);
	LaunchParams(LaunchParams&&);
	LaunchParams& operator=(LaunchParams&&);
	LaunchParams(const LaunchParams&) = delete;
	LaunchParams& operator=(const LaunchParams&) = delete;
	~LaunchParams();

	base::CommandLine command_line;

	base::LaunchOptions options;
	};

	// Results from `LaunchProcess` and needs to be passed to
	// BrowserManager.
	struct LaunchResults {
	public:
	LaunchResults();
	LaunchResults(LaunchResults&&);
	LaunchResults& operator=(LaunchResults&&);
	LaunchResults(const LaunchResults&) = delete;
	LaunchResults& operator=(const LaunchResults&) = delete;
	~LaunchResults();

	// ID for the current Crosapi connection.
	// Available only when lacros-chrome is running.
	CrosapiId crosapi_id;

	// Time when the lacros process was launched.
	base::TimeTicks lacros_launch_time;
	};

	// Reason of Lacros not being able to launch.
	enum class LaunchFailureReason {
	// Failed to launch due to unknown error.
	kUnknown,

	// Shutdown is requested from BrowserManager during the process launch.
	kShutdownRequested,
	};

	using LaunchCompletionCallback = base::OnceCallback<void(
	base::expected<LaunchResults, LaunchFailureReason>)>;

	// Launches a process of the given options, which are expected to be Lacros's
	// ones.
	// `Launch` will:
	// 1. Prepare launching on background thread to handle blocking resources.
	// 2. Wait for device owner and primary user if it's launching in the user
	// session.
	// 3. Launch lacros process with the params prepared at Step 1.
	//
	// Following is explanation for Arguments.
	// `chrome_path`: Initializes `command_line`.
	// `launching_at_login_screen`: Whether lacros is launching at login screen.
	// `postlogin_pipe_fd`: Pipe FDs through which Ash and Lacros exchange
	// post-login parameters.
	// `lacros_selection`: Whether "rootfs" or "stateful" lacros is selected.
	// `mojo_disconnection_cb`: Callback function setting up mojo connection.
	// `BrowserManager::OnMojoDisconnected` is called.
	// `is_keep_alive_enabled`: Whether `keep_alive_features` is empty.
	// `callback`: Callback function that will be called on launch process
	// completion.
	void Launch(const base::FilePath& chrome_path,
	bool launching_at_login_screen,
	ash::standalone_browser::LacrosSelection lacros_selection,
	base::OnceClosure mojo_disconnection_cb,
	bool is_keep_alive_enabled,
	LaunchCompletionCallback callback);

	// Writes post login data to the Lacros process, resets `postlogin_pipe_fd`
	// and then executes a callback.
	void ResumeLaunch(
	base::OnceCallback<
	void(base::expected<base::TimeTicks, LaunchFailureReason>)> callback);

	// Returns true if process is valid.
	bool IsProcessValid() const;

	// Triggers termination synchronously if process is running.
	// Does not block the thread because it does not wait for the process
	// termination.
	bool TriggerTerminate(int exit_code) const;

	// Waits for termination of the running process asynchronously during the
	// period given by the `timeout`, then invoke `callback`. On timeout, also
	// tries to terminate the process by sending a signal.
	// TODO(mayukoaiba): On calling this function, even before the termination
	// procedure is completed (i.e. before `callback` is called), IsProcessValid
	// will return false and LaunchProcess tries to create the next process, which
	// may be confusing for callers. We should fix this issue.
	void EnsureProcessTerminated(base::OnceClosure callback,
	base::TimeDelta timeout);

	// Records Shutdown() request from BrowserManager.
	void Shutdown() { shutdown_requested_ = true; }

	// Returns reference to `process_` for testing.
	const base::Process& GetProcessForTesting() const;

	// Provides public API to call LaunchProcessWithParameters for testing.
	bool LaunchProcessForTesting(const LaunchParams& parameters);

	// Provides public API to call CreateLaunchParamsForTesting for testing.
	LaunchParams CreateLaunchParamsForTesting(
	const base::FilePath& chrome_path,
	const LaunchParamsFromBackground& params,
	bool launching_at_login_screen,
	std::optional<int> startup_fd,
	std::optional<int> read_pipe_fd,
	mojo::PlatformChannel& channel,
	ash::standalone_browser::LacrosSelection lacros_selection);

	// Creates postlogin pipe fd and returns the read fd. This is used to test
	// ResumeLaunch. Note that the reader is on the same process and does not
	// launch testing process.
	base::ScopedFD CreatePostLoginPipeForTesting();

	// Sets up additional flags for unit tests.
	// This function overwrites `command_line` with the desired flags.
	void SetUpAdditionalParametersForTesting(LaunchParamsFromBackground& params,
	LaunchParams& parameters) const;

	// Provides public API to call WaitForBackgroundWorkPreLaunch for testing.
	void WaitForBackgroundWorkPreLaunchForTesting(
	const base::FilePath& lacros_dir,
	bool clear_shared_resource_file,
	bool launching_at_login_screen,
	base::OnceClosure callback,
	LaunchParamsFromBackground& params);

	// TODO(crbug.com/40275396): Remove this once we refactored to use the
	// constructor.
	void set_device_ownership_waiter_for_testing(
	std::unique_ptr<user_manager::DeviceOwnershipWaiter>
	device_ownership_waiter);

	// Skips device ownership fetch. Use set_device_ownership_waiter_for_testing()
	// above if possible. Use this method only if your test must set up the
	// behavior before BrowserManager is initialized.
	// TODO(crbug.com/40275396): Remove this and set it from constructor.
	static void SkipDeviceOwnershipWaitForTesting(bool skip);

	private:
	// Waits for the prelaunch work running on background thread. `callback` is
	// called on background work completion and the output result is stored in
	// `params`.
	void WaitForBackgroundWorkPreLaunch(const base::FilePath& lacros_dir,
	bool clear_shared_resource_file,
	bool launching_at_login_screen,
	base::OnceClosure callback,
	LaunchParamsFromBackground& params);

	// Waits for the device owner being fetched from `UserManager` or the primary
	// user profile being fully created and then executes a callback. Should NOT
	// be called if Lacros is launching at the login screen since the device owner
	// nor the profile is not available until login.
	void WaitForDeviceOwnerFetchedAndThen(base::OnceClosure callback);
	void WaitForPrimaryProfileAddedAndThen(base::OnceClosure callback);

	// Launches lacros-chrome process after device owner and primary profile
	// become ready.
	void LaunchProcess(const base::FilePath& chrome_path,
	std::unique_ptr<LaunchParamsFromBackground> params,
	bool launching_at_login_screen,
	ash::standalone_browser::LacrosSelection lacros_selection,
	base::OnceClosure mojo_disconnection_cb,
	bool is_keep_alive_enabled,
	LaunchCompletionCallback callback);

	LaunchParams CreateLaunchParams(
	const base::FilePath& chrome_path,
	const LaunchParamsFromBackground& params,
	bool launching_at_login_screen,
	std::optional<int> startup_fd,
	std::optional<int> read_pipe_fd,
	mojo::PlatformChannel& channel,
	ash::standalone_browser::LacrosSelection lacros_selection);

	// Launches a process , which is executed in `LaunchProcess`.
	// This is also used for unittest.
	bool LaunchProcessWithParameters(const LaunchParams& parameters);

	// Writes post login data after waiting for device owner and profile to be
	// ready.
	void WritePostLoginData(
	base::OnceCallback<
	void(base::expected<base::TimeTicks, LaunchFailureReason>)> callback);

	// Process handle for the lacros_chrome process.
	base::Process process_;

	// Pipe FDs through which Ash and Lacros exchange post-login parameters.
	base::ScopedFD postlogin_pipe_fd_;

	// Used to delay an action until the definitive device owner is fetched.
	std::unique_ptr<user_manager::DeviceOwnershipWaiter> device_ownership_waiter_;

	// Used to wait for the primary user profile to be fully created.
	std::unique_ptr<PrimaryProfileCreationWaiter>
	primary_profile_creation_waiter_;

	// Tracks whether Shutdown() has been signalled by ash. This flag ensures any
	// new or existing lacros startup tasks are not executed during shutdown.
	bool shutdown_requested_ = false;

	// True if this is the first time that lacros is being launched from this ash
	// process. This value is used for resource sharing feature where ash deletes
	// cached shared resource file after ash is rebooted. Note that this flag
	// should not be reset on reloading as long as the ash process is not
	// relaunched.
	bool is_first_lacros_launch_ = true;

	// Indicates whether the delegate has been used.
	bool device_ownership_waiter_called_ = false;

	base::WeakPtrFactory<BrowserLauncher> weak_factory_{this};
	};

	} // namespace crosapi

	#endif // CHROME_BROWSER_ASH_CROSAPI_BROWSER_LAUNCHER_H_