// Copyright 2018 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef CHROMEOS_ASH_COMPONENTS_DBUS_CICERONE_FAKE_CICERONE_CLIENT_H_
#define CHROMEOS_ASH_COMPONENTS_DBUS_CICERONE_FAKE_CICERONE_CLIENT_H_
#include "base/memory/weak_ptr.h"
#include "base/observer_list.h"
#include "base/time/time.h"
#include "chromeos/ash/components/dbus/cicerone/cicerone_client.h"
#include "chromeos/ash/components/dbus/cicerone/cicerone_service.pb.h"
namespace ash {
// FakeCiceroneClient is a fake implementation of CiceroneClient used for
// testing.
class COMPONENT_EXPORT(CICERONE) FakeCiceroneClient : public CiceroneClient {
public:
using LaunchContainerApplicationCallback = base::RepeatingCallback<void(
const vm_tools::cicerone::LaunchContainerApplicationRequest& request,
chromeos::DBusMethodCallback<
vm_tools::cicerone::LaunchContainerApplicationResponse> callback)>;
using UninstallPackageOwningFileCallback = base::RepeatingCallback<void(
const vm_tools::cicerone::UninstallPackageOwningFileRequest&,
chromeos::DBusMethodCallback<
vm_tools::cicerone::UninstallPackageOwningFileResponse>)>;
// Returns the fake global instance if initialized. May return null.
static FakeCiceroneClient* Get();
FakeCiceroneClient(const FakeCiceroneClient&) = delete;
FakeCiceroneClient& operator=(const FakeCiceroneClient&) = delete;
// CiceroneClient:
void AddObserver(Observer* observer) override;
void RemoveObserver(Observer* observer) override;
bool IsContainerStartedSignalConnected() override;
bool IsContainerShutdownSignalConnected() override;
bool IsInstallLinuxPackageProgressSignalConnected() override;
bool IsUninstallPackageProgressSignalConnected() override;
bool IsLxdContainerCreatedSignalConnected() override;
bool IsLxdContainerDeletedSignalConnected() override;
bool IsLxdContainerDownloadingSignalConnected() override;
bool IsTremplinStartedSignalConnected() override;
bool IsLxdContainerStartingSignalConnected() override;
bool IsExportLxdContainerProgressSignalConnected() override;
bool IsImportLxdContainerProgressSignalConnected() override;
bool IsPendingAppListUpdatesSignalConnected() override;
bool IsApplyAnsiblePlaybookProgressSignalConnected() override;
bool IsUpgradeContainerProgressSignalConnected() override;
bool IsStartLxdProgressSignalConnected() override;
bool IsFileWatchTriggeredSignalConnected() override;
bool IsLowDiskSpaceTriggeredSignalConnected() override;
bool IsInhibitScreensaverSignalConencted() override;
bool IsUninhibitScreensaverSignalConencted() override;
void LaunchContainerApplication(
const vm_tools::cicerone::LaunchContainerApplicationRequest& request,
chromeos::DBusMethodCallback<
vm_tools::cicerone::LaunchContainerApplicationResponse> callback)
override;
void GetContainerAppIcons(
const vm_tools::cicerone::ContainerAppIconRequest& request,
chromeos::DBusMethodCallback<vm_tools::cicerone::ContainerAppIconResponse>
callback) override;
void GetLinuxPackageInfo(
const vm_tools::cicerone::LinuxPackageInfoRequest& request,
chromeos::DBusMethodCallback<vm_tools::cicerone::LinuxPackageInfoResponse>
callback) override;
// Fake version of the method that installs an application inside a running
// Container. |callback| is called after the method call finishes. This does
// not cause progress events to be fired.
void InstallLinuxPackage(
const vm_tools::cicerone::InstallLinuxPackageRequest& request,
chromeos::DBusMethodCallback<
vm_tools::cicerone::InstallLinuxPackageResponse> callback) override;
// If SetOnUninstallPackageOwningFileCallback has been called, it
// just triggers that callback. Otherwise, it generates a task to call
// |callback| with the response from
// set_uninstall_package_owning_file_response.
void UninstallPackageOwningFile(
const vm_tools::cicerone::UninstallPackageOwningFileRequest& request,
chromeos::DBusMethodCallback<
vm_tools::cicerone::UninstallPackageOwningFileResponse> callback)
override;
void CreateLxdContainer(
const vm_tools::cicerone::CreateLxdContainerRequest& request,
chromeos::DBusMethodCallback<
vm_tools::cicerone::CreateLxdContainerResponse> callback) override;
void DeleteLxdContainer(
const vm_tools::cicerone::DeleteLxdContainerRequest& request,
chromeos::DBusMethodCallback<
vm_tools::cicerone::DeleteLxdContainerResponse> callback) override;
void StartLxdContainer(
const vm_tools::cicerone::StartLxdContainerRequest& request,
chromeos::DBusMethodCallback<
vm_tools::cicerone::StartLxdContainerResponse> callback) override;
void StopLxdContainer(
const vm_tools::cicerone::StopLxdContainerRequest& request,
chromeos::DBusMethodCallback<vm_tools::cicerone::StopLxdContainerResponse>
callback) override;
void GetLxdContainerUsername(
const vm_tools::cicerone::GetLxdContainerUsernameRequest& request,
chromeos::DBusMethodCallback<
vm_tools::cicerone::GetLxdContainerUsernameResponse> callback)
override;
void SetUpLxdContainerUser(
const vm_tools::cicerone::SetUpLxdContainerUserRequest& request,
chromeos::DBusMethodCallback<
vm_tools::cicerone::SetUpLxdContainerUserResponse> callback) override;
void ExportLxdContainer(
const vm_tools::cicerone::ExportLxdContainerRequest& request,
chromeos::DBusMethodCallback<
vm_tools::cicerone::ExportLxdContainerResponse> callback) override;
void ImportLxdContainer(
const vm_tools::cicerone::ImportLxdContainerRequest& request,
chromeos::DBusMethodCallback<
vm_tools::cicerone::ImportLxdContainerResponse> callback) override;
void CancelExportLxdContainer(
const vm_tools::cicerone::CancelExportLxdContainerRequest& request,
chromeos::DBusMethodCallback<
vm_tools::cicerone::CancelExportLxdContainerResponse> callback)
override;
void CancelImportLxdContainer(
const vm_tools::cicerone::CancelImportLxdContainerRequest& request,
chromeos::DBusMethodCallback<
vm_tools::cicerone::CancelImportLxdContainerResponse> callback)
override;
void ApplyAnsiblePlaybook(
const vm_tools::cicerone::ApplyAnsiblePlaybookRequest& request,
chromeos::DBusMethodCallback<
vm_tools::cicerone::ApplyAnsiblePlaybookResponse> callback) override;
void ConfigureForArcSideload(
const vm_tools::cicerone::ConfigureForArcSideloadRequest& request,
chromeos::DBusMethodCallback<
vm_tools::cicerone::ConfigureForArcSideloadResponse> callback)
override;
void UpgradeContainer(
const vm_tools::cicerone::UpgradeContainerRequest& request,
chromeos::DBusMethodCallback<vm_tools::cicerone::UpgradeContainerResponse>
callback) override;
void CancelUpgradeContainer(
const vm_tools::cicerone::CancelUpgradeContainerRequest& request,
chromeos::DBusMethodCallback<
vm_tools::cicerone::CancelUpgradeContainerResponse> callback)
override;
void StartLxd(
const vm_tools::cicerone::StartLxdRequest& request,
chromeos::DBusMethodCallback<vm_tools::cicerone::StartLxdResponse>
callback) override;
void AddFileWatch(
const vm_tools::cicerone::AddFileWatchRequest& request,
chromeos::DBusMethodCallback<vm_tools::cicerone::AddFileWatchResponse>
callback) override;
void RemoveFileWatch(
const vm_tools::cicerone::RemoveFileWatchRequest& request,
chromeos::DBusMethodCallback<vm_tools::cicerone::RemoveFileWatchResponse>
callback) override;
void GetVshSession(
const vm_tools::cicerone::GetVshSessionRequest& request,
chromeos::DBusMethodCallback<vm_tools::cicerone::GetVshSessionResponse>
callback) override;
void AttachUsbToContainer(
const vm_tools::cicerone::AttachUsbToContainerRequest& request,
chromeos::DBusMethodCallback<
vm_tools::cicerone::AttachUsbToContainerResponse> callback) override;
void DetachUsbFromContainer(
const vm_tools::cicerone::DetachUsbFromContainerRequest& request,
chromeos::DBusMethodCallback<
vm_tools::cicerone::DetachUsbFromContainerResponse> callback)
override;
void FileSelected(
const vm_tools::cicerone::FileSelectedSignal& signal) override;
void ListRunningContainers(
const vm_tools::cicerone::ListRunningContainersRequest& request,
chromeos::DBusMethodCallback<
vm_tools::cicerone::ListRunningContainersResponse> callback) override;
void GetGarconSessionInfo(
const vm_tools::cicerone::GetGarconSessionInfoRequest& request,
chromeos::DBusMethodCallback<
vm_tools::cicerone::GetGarconSessionInfoResponse> callback) override;
void UpdateContainerDevices(
const vm_tools::cicerone::UpdateContainerDevicesRequest& request,
chromeos::DBusMethodCallback<
vm_tools::cicerone::UpdateContainerDevicesResponse> callback)
override;
void WaitForServiceToBeAvailable(
dbus::ObjectProxy::WaitForServiceToBeAvailableCallback callback) override;
// Sets a callback to be called during any call to LaunchContainerApplication.
void SetOnLaunchContainerApplicationCallback(
LaunchContainerApplicationCallback callback);
// Sets a callback to be called during any call to UninstallPackageOwningFile.
void SetOnUninstallPackageOwningFileCallback(
UninstallPackageOwningFileCallback callback);
void set_container_started_signal_connected(bool connected) {
is_container_started_signal_connected_ = connected;
}
void set_container_shutdown_signal_connected(bool connected) {
is_container_shutdown_signal_connected_ = connected;
}
void set_install_linux_package_progress_signal_connected(bool connected) {
is_install_linux_package_progress_signal_connected_ = connected;
}
void set_uninstall_package_progress_signal_connected(bool connected) {
is_uninstall_package_progress_signal_connected_ = connected;
}
void set_lxd_container_created_signal_connected(bool connected) {
is_lxd_container_created_signal_connected_ = connected;
}
void set_lxd_container_created_signal_status(
vm_tools::cicerone::LxdContainerCreatedSignal_Status status) {
lxd_container_created_signal_status_ = status;
}
void set_lxd_container_deleted_signal_connected(bool connected) {
is_lxd_container_deleted_signal_connected_ = connected;
}
void set_lxd_container_deleted_signal_status(
vm_tools::cicerone::LxdContainerDeletedSignal_Status status) {
lxd_container_deleted_signal_status_ = status;
}
void set_lxd_container_downloading_signal_connected(bool connected) {
is_lxd_container_downloading_signal_connected_ = connected;
}
void set_tremplin_started_signal_connected(bool connected) {
is_tremplin_started_signal_connected_ = connected;
}
void set_lxd_container_starting_signal_connected(bool connected) {
is_lxd_container_starting_signal_connected_ = connected;
}
void set_export_lxd_container_progress_signal_connected(bool connected) {
is_export_lxd_container_progress_signal_connected_ = connected;
}
void set_import_lxd_container_progress_signal_connected(bool connected) {
is_import_lxd_container_progress_signal_connected_ = connected;
}
void set_upgrade_container_progress_signal_connected(bool connected) {
is_upgrade_container_progress_signal_connected_ = connected;
}
void set_start_lxd_progress_signal_connected(bool connected) {
is_start_lxd_progress_signal_connected_ = connected;
}
void set_file_watch_triggered_signal_connected(bool connected) {
is_file_watch_triggered_signal_connected_ = connected;
}
void set_low_disk_space_triggered_signal_connected(bool connected) {
is_low_disk_space_triggered_signal_connected_ = connected;
}
void set_launch_container_application_response(
const vm_tools::cicerone::LaunchContainerApplicationResponse&
launch_container_application_response) {
launch_container_application_response_ =
launch_container_application_response;
}
void set_container_app_icon_response(
const vm_tools::cicerone::ContainerAppIconResponse&
container_app_icon_response) {
container_app_icon_response_ = container_app_icon_response;
}
const vm_tools::cicerone::LinuxPackageInfoRequest&
get_most_recent_linux_package_info_request() const {
return most_recent_linux_package_info_request_;
}
void set_linux_package_info_response(
const vm_tools::cicerone::LinuxPackageInfoResponse&
get_linux_package_info_response) {
get_linux_package_info_response_ = get_linux_package_info_response;
}
const vm_tools::cicerone::InstallLinuxPackageRequest&
get_most_recent_install_linux_package_request() const {
return most_recent_install_linux_package_request_;
}
void set_install_linux_package_response(
const vm_tools::cicerone::InstallLinuxPackageResponse&
install_linux_package_response) {
install_linux_package_response_ = install_linux_package_response;
}
void set_uninstall_package_owning_file_response(
const vm_tools::cicerone::UninstallPackageOwningFileResponse&
uninstall_package_owning_file_response) {
uninstall_package_owning_file_response_ =
uninstall_package_owning_file_response;
}
void set_create_lxd_container_response(
const vm_tools::cicerone::CreateLxdContainerResponse&
create_lxd_container_response) {
create_lxd_container_response_ = create_lxd_container_response;
}
void set_delete_lxd_container_response_(
const vm_tools::cicerone::DeleteLxdContainerResponse&
delete_lxd_container_response) {
delete_lxd_container_response_ = delete_lxd_container_response;
}
void set_start_lxd_container_response(
const vm_tools::cicerone::StartLxdContainerResponse&
start_lxd_container_response) {
start_lxd_container_response_ = start_lxd_container_response;
}
void set_stop_lxd_container_response(
const vm_tools::cicerone::StopLxdContainerResponse&
stop_lxd_container_response) {
stop_lxd_container_response_ = stop_lxd_container_response;
}
void set_get_lxd_container_username_response(
const vm_tools::cicerone::GetLxdContainerUsernameResponse&
get_lxd_container_username_response) {
get_lxd_container_username_response_ = get_lxd_container_username_response;
}
void set_setup_lxd_container_user_response(
const vm_tools::cicerone::SetUpLxdContainerUserResponse&
setup_lxd_container_user_response) {
setup_lxd_container_user_response_ = setup_lxd_container_user_response;
}
void set_export_lxd_container_response(
const vm_tools::cicerone::ExportLxdContainerResponse&
export_lxd_container_response) {
export_lxd_container_response_ = export_lxd_container_response;
}
void set_import_lxd_container_response(
const vm_tools::cicerone::ImportLxdContainerResponse&
import_lxd_container_response) {
import_lxd_container_response_ = import_lxd_container_response;
}
void set_cancel_export_lxd_container_response(
vm_tools::cicerone::CancelExportLxdContainerResponse
cancel_export_lxd_container_response) {
cancel_export_lxd_container_response_ =
std::move(cancel_export_lxd_container_response);
}
void set_cancel_import_lxd_container_response(
vm_tools::cicerone::CancelImportLxdContainerResponse
cancel_import_lxd_container_response) {
cancel_import_lxd_container_response_ =
std::move(cancel_import_lxd_container_response);
}
void set_lxd_container_os_release(vm_tools::cicerone::OsRelease os_release) {
lxd_container_os_release_ = std::move(os_release);
}
void set_apply_ansible_playbook_response(
const vm_tools::cicerone::ApplyAnsiblePlaybookResponse&
apply_ansible_playbook_response) {
apply_ansible_playbook_response_ = apply_ansible_playbook_response;
}
void set_enable_arc_sideload_response(
const vm_tools::cicerone::ConfigureForArcSideloadResponse& response) {
enable_arc_sideload_response_ = response;
}
void set_upgrade_container_response(
vm_tools::cicerone::UpgradeContainerResponse upgrade_container_response) {
upgrade_container_response_ = std::move(upgrade_container_response);
}
void set_cancel_upgrade_container_response(
vm_tools::cicerone::CancelUpgradeContainerResponse
cancel_upgrade_container_response) {
cancel_upgrade_container_response_ =
std::move(cancel_upgrade_container_response);
}
void set_start_lxd_response(
vm_tools::cicerone::StartLxdResponse start_lxd_response) {
start_lxd_response_ = std::move(start_lxd_response);
}
void set_add_file_watch_response(
vm_tools::cicerone::AddFileWatchResponse add_file_watch_response) {
add_file_watch_response_ = std::move(add_file_watch_response);
}
void set_remove_file_watch_response(
vm_tools::cicerone::RemoveFileWatchResponse remove_file_watch_response) {
remove_file_watch_response_ = std::move(remove_file_watch_response);
}
void set_get_vsh_session_response(
vm_tools::cicerone::GetVshSessionResponse get_vsh_session_response) {
get_vsh_session_response_ = std::move(get_vsh_session_response);
}
void set_attach_usb_to_container_response(
vm_tools::cicerone::AttachUsbToContainerResponse
attach_usb_to_container_response) {
attach_usb_to_container_response_ =
std::move(attach_usb_to_container_response);
}
void set_detach_usb_from_container_response(
vm_tools::cicerone::DetachUsbFromContainerResponse
detach_usb_from_container_response) {
detach_usb_from_container_response_ =
std::move(detach_usb_from_container_response);
}
void set_list_containers_response(
vm_tools::cicerone::ListRunningContainersResponse
list_container_response) {
list_containers_response_ = std::move(list_container_response);
}
void set_get_garcon_session_info_response(
vm_tools::cicerone::GetGarconSessionInfoResponse
get_garcon_session_info_response) {
get_garcon_session_info_response_ =
std::move(get_garcon_session_info_response);
}
void set_update_container_devices_response(
vm_tools::cicerone::UpdateContainerDevicesResponse
update_container_devices_response) {
update_container_devices_response_ =
std::move(update_container_devices_response);
}
void set_send_container_starting_signal_delay(base::TimeDelta delay) {
send_container_starting_signal_delay_ = delay;
}
void set_send_container_started_signal_delay(base::TimeDelta delay) {
send_container_started_signal_delay_ = delay;
}
void set_send_start_lxd_response_delay(base::TimeDelta delay) {
send_start_lxd_response_delay_ = delay;
}
void set_send_create_lxd_container_response_delay(base::TimeDelta delay) {
send_create_lxd_container_response_delay_ = delay;
}
void set_send_notify_lxd_container_created_signal_delay(
base::TimeDelta delay) {
send_notify_lxd_container_created_signal_delay_ = delay;
}
void set_send_set_up_lxd_container_user_response_delay(
base::TimeDelta delay) {
send_set_up_lxd_container_user_response_delay_ = delay;
}
void set_send_start_lxd_container_response_delay(base::TimeDelta delay) {
send_start_lxd_container_response_delay_ = delay;
}
void set_send_stop_lxd_container_response_delay(base::TimeDelta delay) {
send_stop_lxd_container_response_delay_ = delay;
}
vm_tools::cicerone::SetUpLxdContainerUserRequest
get_setup_lxd_container_user_request() {
return setup_lxd_container_user_request_;
}
// Returns true if the method has been invoked at least once, false otherwise.
bool configure_for_arc_sideload_called() {
return configure_for_arc_sideload_called_;
}
int create_lxd_container_count() { return create_lxd_container_count_; }
int start_lxd_container_count() { return start_lxd_container_count_; }
int setup_lxd_container_user_count() {
return setup_lxd_container_user_count_;
}
int start_lxd_count() { return start_lxd_count_; }
int add_file_watch_call_count() { return add_file_watch_call_count_; }
int remove_file_watch_call_count() { return remove_file_watch_call_count_; }
// Additional functions to allow tests to trigger Signals.
void NotifyLxdContainerCreated(
const vm_tools::cicerone::LxdContainerCreatedSignal& signal);
void NotifyLxdContainerDeleted(
const vm_tools::cicerone::LxdContainerDeletedSignal& signal);
void NotifyContainerStarted(
const vm_tools::cicerone::ContainerStartedSignal& signal);
void NotifyContainerShutdownSignal(
const vm_tools::cicerone::ContainerShutdownSignal& signal);
void NotifyTremplinStarted(
const vm_tools::cicerone::TremplinStartedSignal& signal);
void NotifyLxdContainerStarting(
const vm_tools::cicerone::LxdContainerStartingSignal& signal);
void NotifyExportLxdContainerProgress(
const vm_tools::cicerone::ExportLxdContainerProgressSignal& signal);
void NotifyImportLxdContainerProgress(
const vm_tools::cicerone::ImportLxdContainerProgressSignal& signal);
void InstallLinuxPackageProgress(
const vm_tools::cicerone::InstallLinuxPackageProgressSignal& signal);
void UninstallPackageProgress(
const vm_tools::cicerone::UninstallPackageProgressSignal& signal);
void NotifyPendingAppListUpdates(
const vm_tools::cicerone::PendingAppListUpdatesSignal& signal);
void NotifyApplyAnsiblePlaybookProgress(
const vm_tools::cicerone::ApplyAnsiblePlaybookProgressSignal& signal);
void NotifyUpgradeContainerProgress(
const vm_tools::cicerone::UpgradeContainerProgressSignal& signal);
void NotifyStartLxdProgress(
const vm_tools::cicerone::StartLxdProgressSignal& signal);
void NotifyFileWatchTriggered(
const vm_tools::cicerone::FileWatchTriggeredSignal& signal);
void NotifyCiceroneStopped();
void NotifyCiceroneStarted();
protected:
friend class CiceroneClient;
FakeCiceroneClient();
~FakeCiceroneClient() override;
void Init(dbus::Bus* bus) override {}
private:
bool is_container_started_signal_connected_ = true;
bool is_container_shutdown_signal_connected_ = true;
bool is_install_linux_package_progress_signal_connected_ = true;
bool is_uninstall_package_progress_signal_connected_ = true;
bool is_lxd_container_created_signal_connected_ = true;
bool is_lxd_container_deleted_signal_connected_ = true;
bool is_lxd_container_downloading_signal_connected_ = true;
bool is_tremplin_started_signal_connected_ = true;
bool is_lxd_container_starting_signal_connected_ = true;
bool is_export_lxd_container_progress_signal_connected_ = true;
bool is_import_lxd_container_progress_signal_connected_ = true;
bool is_apply_ansible_playbook_progress_signal_connected_ = true;
bool is_upgrade_container_progress_signal_connected_ = true;
bool is_start_lxd_progress_signal_connected_ = true;
bool is_file_watch_triggered_signal_connected_ = true;
bool is_low_disk_space_triggered_signal_connected_ = true;
bool is_inhibit_screensaver_signal_connected_ = true;
bool is_uninhibit_screensaver_signal_connected_ = true;
std::string last_container_username_;
bool configure_for_arc_sideload_called_ = false;
int create_lxd_container_count_ = 0;
int start_lxd_container_count_ = 0;
int setup_lxd_container_user_count_ = 0;
int start_lxd_count_ = 0;
int add_file_watch_call_count_ = 0;
int remove_file_watch_call_count_ = 0;
vm_tools::cicerone::LxdContainerCreatedSignal_Status
lxd_container_created_signal_status_ =
vm_tools::cicerone::LxdContainerCreatedSignal::CREATED;
vm_tools::cicerone::LxdContainerDeletedSignal_Status
lxd_container_deleted_signal_status_ =
vm_tools::cicerone::LxdContainerDeletedSignal::DELETED;
vm_tools::cicerone::LxdContainerStartingSignal_Status
lxd_container_starting_signal_status_ =
vm_tools::cicerone::LxdContainerStartingSignal::STARTED;
vm_tools::cicerone::LaunchContainerApplicationResponse
launch_container_application_response_;
vm_tools::cicerone::ContainerAppIconResponse container_app_icon_response_;
vm_tools::cicerone::LinuxPackageInfoRequest
most_recent_linux_package_info_request_;
vm_tools::cicerone::LinuxPackageInfoResponse get_linux_package_info_response_;
vm_tools::cicerone::InstallLinuxPackageRequest
most_recent_install_linux_package_request_;
vm_tools::cicerone::InstallLinuxPackageResponse
install_linux_package_response_;
vm_tools::cicerone::UninstallPackageOwningFileResponse
uninstall_package_owning_file_response_;
vm_tools::cicerone::CreateLxdContainerResponse create_lxd_container_response_;
vm_tools::cicerone::DeleteLxdContainerResponse delete_lxd_container_response_;
vm_tools::cicerone::StartLxdContainerResponse start_lxd_container_response_;
vm_tools::cicerone::StopLxdContainerResponse stop_lxd_container_response_;
vm_tools::cicerone::GetLxdContainerUsernameResponse
get_lxd_container_username_response_;
vm_tools::cicerone::SetUpLxdContainerUserResponse
setup_lxd_container_user_response_;
vm_tools::cicerone::ExportLxdContainerResponse export_lxd_container_response_;
vm_tools::cicerone::ImportLxdContainerResponse import_lxd_container_response_;
vm_tools::cicerone::CancelExportLxdContainerResponse
cancel_export_lxd_container_response_;
vm_tools::cicerone::CancelImportLxdContainerResponse
cancel_import_lxd_container_response_;
vm_tools::cicerone::ApplyAnsiblePlaybookResponse
apply_ansible_playbook_response_;
vm_tools::cicerone::ConfigureForArcSideloadResponse
enable_arc_sideload_response_;
vm_tools::cicerone::UpgradeContainerResponse upgrade_container_response_;
vm_tools::cicerone::CancelUpgradeContainerResponse
cancel_upgrade_container_response_;
vm_tools::cicerone::StartLxdResponse start_lxd_response_;
vm_tools::cicerone::AddFileWatchResponse add_file_watch_response_;
vm_tools::cicerone::RemoveFileWatchResponse remove_file_watch_response_;
vm_tools::cicerone::GetVshSessionResponse get_vsh_session_response_;
vm_tools::cicerone::AttachUsbToContainerResponse
attach_usb_to_container_response_;
vm_tools::cicerone::DetachUsbFromContainerResponse
detach_usb_from_container_response_;
vm_tools::cicerone::ListRunningContainersResponse list_containers_response_;
vm_tools::cicerone::GetGarconSessionInfoResponse
get_garcon_session_info_response_;
vm_tools::cicerone::UpdateContainerDevicesResponse
update_container_devices_response_;
base::TimeDelta send_container_starting_signal_delay_;
base::TimeDelta send_container_started_signal_delay_;
base::TimeDelta send_start_lxd_response_delay_;
base::TimeDelta send_create_lxd_container_response_delay_;
base::TimeDelta send_notify_lxd_container_created_signal_delay_;
base::TimeDelta send_set_up_lxd_container_user_response_delay_;
base::TimeDelta send_start_lxd_container_response_delay_;
base::TimeDelta send_stop_lxd_container_response_delay_;
vm_tools::cicerone::SetUpLxdContainerUserRequest
setup_lxd_container_user_request_;
vm_tools::cicerone::OsRelease lxd_container_os_release_;
LaunchContainerApplicationCallback launch_container_application_callback_;
UninstallPackageOwningFileCallback uninstall_package_owning_file_callback_;
base::ObserverList<Observer>::Unchecked observer_list_;
base::WeakPtrFactory<FakeCiceroneClient> weak_factory_{this};
};
} // namespace ash
#endif // CHROMEOS_ASH_COMPONENTS_DBUS_CICERONE_FAKE_CICERONE_CLIENT_H_
Codebase Browser
chromium