chrome/browser/ash/crostini/crostini_package_service.h - chromium/src - Git at Google

 // 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 CHROME_BROWSER_ASH_CROSTINI_CROSTINI_PACKAGE_SERVICE_H_
 #define CHROME_BROWSER_ASH_CROSTINI_CROSTINI_PACKAGE_SERVICE_H_

 #include <map>
 #include <memory>
 #include <queue>
 #include <set>
 #include <string>
 #include <utility>
 #include <vector>

 #include "base/functional/callback_forward.h"
 #include "base/memory/raw_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "chrome/browser/ash/crostini/crostini_manager.h"
 #include "chrome/browser/ash/crostini/crostini_package_notification.h"
 #include "chrome/browser/ash/crostini/crostini_package_operation_status.h"
 #include "chrome/browser/ash/crostini/crostini_util.h"
 #include "chrome/browser/ash/guest_os/guest_os_registry_service.h"
 #include "components/keyed_service/core/keyed_service.h"
 #include "storage/browser/file_system/file_system_url.h"

 namespace crostini {

 class CrostiniPackageService : public KeyedService,
                                public LinuxPackageOperationProgressObserver,
                                public PendingAppListUpdatesObserver,
                                public ash::VmShutdownObserver {
  public:
   using StateChangeCallback =
       base::RepeatingCallback<void(PackageOperationStatus)>;

   static CrostiniPackageService* GetForProfile(Profile* profile);

   explicit CrostiniPackageService(Profile* profile);

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

   ~CrostiniPackageService() override;

   // For testing: Set a callback that will be called each time a notification
   // is set to a new state.
   void SetNotificationStateChangeCallbackForTesting(
       StateChangeCallback state_change_callback);

   // KeyedService:
   void Shutdown() override;

   void NotificationCompleted(CrostiniPackageNotification* notification);

   void GetLinuxPackageInfo(
       const guest_os::GuestId& container_id,
       const storage::FileSystemURL& package_url,
       CrostiniManager::GetLinuxPackageInfoCallback callback);

   // LinuxPackageOperationProgressObserver:
   void OnInstallLinuxPackageProgress(const guest_os::GuestId& container_id,
                                      InstallLinuxPackageProgressStatus status,
                                      int progress_percent,
                                      const std::string& error_message) override;

   void OnUninstallPackageProgress(const guest_os::GuestId& container_id,
                                   UninstallPackageProgressStatus status,
                                   int progress_percent) override;

   // PendingAppListUpdatesObserver:
   void OnPendingAppListUpdates(const guest_os::GuestId& container_id,
                                int count) override;

   // ash::VmShutdownObserver
   void OnVmShutdown(const std::string& vm_name) override;

   // (Eventually) install a Linux package. If successfully started, a system
   // notification will be used to display further updates.
   void QueueInstallLinuxPackage(
       const guest_os::GuestId& container_id,
       const storage::FileSystemURL& package_url,
       CrostiniManager::InstallLinuxPackageCallback callback);

   // (Eventually) uninstall the package identified by |app_id|. If successfully
   // started, a system notification will be used to display further updates.
   void QueueUninstallApplication(const std::string& app_id);

   CrostiniManager::RestartId GetRestartIdForTesting();

   static void EnsureFactoryBuilt();

  private:
   // The user can request new operations while a different operation is in
   // progress. Rather than sending a request which will fail, just queue the
   // request until the previous one is done.
   struct QueuedInstall;
   struct QueuedUninstall;

   bool ContainerHasRunningOperation(
       const guest_os::GuestId& container_id) const;
   bool ContainerHasQueuedOperation(const guest_os::GuestId& container_id) const;

   // Creates a new notification and adds it to running_notifications_.
   // |app_name| is the name of the application being modified, if any -- for
   // installs, it will be blank, but for uninstalls, it will have the localized
   // name of the application in UTF8.
   // If there is a running notification, it will be set to error state. Caller
   // should check before calling this if a different behavior is desired.
   void CreateRunningNotification(
       const guest_os::GuestId& container_id,
       CrostiniPackageNotification::NotificationType notification_type,
       const std::string& app_name);

   // Creates a new uninstall notification and adds it to queued_uninstalls_.
   void CreateQueuedUninstall(const guest_os::GuestId& container_id,
                              const std::string& app_id,
                              const std::string& app_name);

   // Creates a new install notification and adds it to queued_installs_.
   void CreateQueuedInstall(
       const guest_os::GuestId& container_id,
       const std::string& package,
       CrostiniManager::InstallLinuxPackageCallback callback);

   // Sets the operation status of the current operation. Sets the notification
   // window's current state and updates containers_with_running_operations_.
   // Note that if status is |SUCCEEDED| or |FAILED|, this may kick off another
   // operation from the queued_uninstalls_ list. When status is |FAILED|, the
   // |error_message| will contain an error reported by the installation process.
   void UpdatePackageOperationStatus(const guest_os::GuestId& container_id,
                                     PackageOperationStatus status,
                                     int progress_percent,
                                     const std::string& error_message = {});

   // Callback between sharing and invoking GetLinuxPackageInfo().
   void OnSharePathForGetLinuxPackageInfo(
       const guest_os::GuestId& container_id,
       const storage::FileSystemURL& package_url,
       const base::FilePath& package_path,
       CrostiniManager::GetLinuxPackageInfoCallback callback,
       CrostiniResult result);

   // Wraps the callback provided in GetLinuxPackageInfo().
   void OnGetLinuxPackageInfo(
       const guest_os::GuestId& container_id,
       CrostiniManager::GetLinuxPackageInfoCallback callback,
       const LinuxPackageInfo& linux_package_info);

   // Wraps the callback provided in InstallLinuxPackage().
   void OnInstallLinuxPackage(
       const guest_os::GuestId& container_id,
       CrostiniManager::InstallLinuxPackageCallback callback,
       CrostiniResult result);

   // Kicks off an uninstall of the given app. Never queues the operation. Helper
   // for QueueUninstallApplication (if the operation can be performed
   // immediately) and StartQueuedOperation.
   void UninstallApplication(
       const guest_os::GuestOsRegistryService::Registration& registration,
       const std::string& app_id);

   // Callback when the Crostini container is up and ready to accept messages.
   // Used by the uninstall flow only.
   void OnCrostiniRunningForUninstall(const guest_os::GuestId& container_id,
                                      const std::string& desktop_file_id,
                                      CrostiniResult result);

   // Callback for CrostiniManager::UninstallPackageOwningFile().
   void OnUninstallPackageOwningFile(const guest_os::GuestId& container_id,
                                     CrostiniResult result);

   // Kick off the next operation in the queue for the given container.
   void StartQueuedOperation(const guest_os::GuestId& container_id);

   std::string GetUniqueNotificationId();

   raw_ptr<Profile> profile_;

   // The notifications in the RUNNING state for each container.
   std::map<guest_os::GuestId, std::unique_ptr<CrostiniPackageNotification>>
       running_notifications_;

   // Installs we want to run when the current operation is done.
   std::map<guest_os::GuestId, std::queue<QueuedInstall>> queued_installs_;

   // Uninstalls we want to run when the current operation is done.
   std::map<guest_os::GuestId, std::queue<QueuedUninstall>> queued_uninstalls_;

   // Notifications in a finished state (either SUCCEEDED or FAILED). We need
   // to keep notifications around until they are dismissed even if we don't
   // update them any more.
   std::vector<std::unique_ptr<CrostiniPackageNotification>>
       finished_notifications_;

   // A map storing which containers have currently pending app list update
   // operations. If a container is not present in the map, we assume no pending
   // updates.
   std::set<guest_os::GuestId> has_pending_app_list_updates_;

   // Called each time a notification is set to a new state.
   StateChangeCallback testing_state_change_callback_;

   int next_notification_id_ = 0;

   CrostiniManager::RestartId restart_id_for_testing_;

   base::WeakPtrFactory<CrostiniPackageService> weak_ptr_factory_{this};
 };

 }  // namespace crostini

 #endif  // CHROME_BROWSER_ASH_CROSTINI_CROSTINI_PACKAGE_SERVICE_H_
	// 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 CHROME_BROWSER_ASH_CROSTINI_CROSTINI_PACKAGE_SERVICE_H_
	#define CHROME_BROWSER_ASH_CROSTINI_CROSTINI_PACKAGE_SERVICE_H_

	#include <map>
	#include <memory>
	#include <queue>
	#include <set>
	#include <string>
	#include <utility>
	#include <vector>

	#include "base/functional/callback_forward.h"
	#include "base/memory/raw_ptr.h"
	#include "base/memory/weak_ptr.h"
	#include "chrome/browser/ash/crostini/crostini_manager.h"
	#include "chrome/browser/ash/crostini/crostini_package_notification.h"
	#include "chrome/browser/ash/crostini/crostini_package_operation_status.h"
	#include "chrome/browser/ash/crostini/crostini_util.h"
	#include "chrome/browser/ash/guest_os/guest_os_registry_service.h"
	#include "components/keyed_service/core/keyed_service.h"
	#include "storage/browser/file_system/file_system_url.h"

	namespace crostini {

	class CrostiniPackageService : public KeyedService,
	public LinuxPackageOperationProgressObserver,
	public PendingAppListUpdatesObserver,
	public ash::VmShutdownObserver {
	public:
	using StateChangeCallback =
	base::RepeatingCallback<void(PackageOperationStatus)>;

	static CrostiniPackageService* GetForProfile(Profile* profile);

	explicit CrostiniPackageService(Profile* profile);

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

	~CrostiniPackageService() override;

	// For testing: Set a callback that will be called each time a notification
	// is set to a new state.
	void SetNotificationStateChangeCallbackForTesting(
	StateChangeCallback state_change_callback);

	// KeyedService:
	void Shutdown() override;

	void NotificationCompleted(CrostiniPackageNotification* notification);

	void GetLinuxPackageInfo(
	const guest_os::GuestId& container_id,
	const storage::FileSystemURL& package_url,
	CrostiniManager::GetLinuxPackageInfoCallback callback);

	// LinuxPackageOperationProgressObserver:
	void OnInstallLinuxPackageProgress(const guest_os::GuestId& container_id,
	InstallLinuxPackageProgressStatus status,
	int progress_percent,
	const std::string& error_message) override;

	void OnUninstallPackageProgress(const guest_os::GuestId& container_id,
	UninstallPackageProgressStatus status,
	int progress_percent) override;

	// PendingAppListUpdatesObserver:
	void OnPendingAppListUpdates(const guest_os::GuestId& container_id,
	int count) override;

	// ash::VmShutdownObserver
	void OnVmShutdown(const std::string& vm_name) override;

	// (Eventually) install a Linux package. If successfully started, a system
	// notification will be used to display further updates.
	void QueueInstallLinuxPackage(
	const guest_os::GuestId& container_id,
	const storage::FileSystemURL& package_url,
	CrostiniManager::InstallLinuxPackageCallback callback);

	// (Eventually) uninstall the package identified by \|app_id\|. If successfully
	// started, a system notification will be used to display further updates.
	void QueueUninstallApplication(const std::string& app_id);

	CrostiniManager::RestartId GetRestartIdForTesting();

	static void EnsureFactoryBuilt();

	private:
	// The user can request new operations while a different operation is in
	// progress. Rather than sending a request which will fail, just queue the
	// request until the previous one is done.
	struct QueuedInstall;
	struct QueuedUninstall;

	bool ContainerHasRunningOperation(
	const guest_os::GuestId& container_id) const;
	bool ContainerHasQueuedOperation(const guest_os::GuestId& container_id) const;

	// Creates a new notification and adds it to running_notifications_.
	// \|app_name\| is the name of the application being modified, if any -- for
	// installs, it will be blank, but for uninstalls, it will have the localized
	// name of the application in UTF8.
	// If there is a running notification, it will be set to error state. Caller
	// should check before calling this if a different behavior is desired.
	void CreateRunningNotification(
	const guest_os::GuestId& container_id,
	CrostiniPackageNotification::NotificationType notification_type,
	const std::string& app_name);

	// Creates a new uninstall notification and adds it to queued_uninstalls_.
	void CreateQueuedUninstall(const guest_os::GuestId& container_id,
	const std::string& app_id,
	const std::string& app_name);

	// Creates a new install notification and adds it to queued_installs_.
	void CreateQueuedInstall(
	const guest_os::GuestId& container_id,
	const std::string& package,
	CrostiniManager::InstallLinuxPackageCallback callback);

	// Sets the operation status of the current operation. Sets the notification
	// window's current state and updates containers_with_running_operations_.
	// Note that if status is \|SUCCEEDED\| or \|FAILED\|, this may kick off another
	// operation from the queued_uninstalls_ list. When status is \|FAILED\|, the
	// \|error_message\| will contain an error reported by the installation process.
	void UpdatePackageOperationStatus(const guest_os::GuestId& container_id,
	PackageOperationStatus status,
	int progress_percent,
	const std::string& error_message = {});

	// Callback between sharing and invoking GetLinuxPackageInfo().
	void OnSharePathForGetLinuxPackageInfo(
	const guest_os::GuestId& container_id,
	const storage::FileSystemURL& package_url,
	const base::FilePath& package_path,
	CrostiniManager::GetLinuxPackageInfoCallback callback,
	CrostiniResult result);

	// Wraps the callback provided in GetLinuxPackageInfo().
	void OnGetLinuxPackageInfo(
	const guest_os::GuestId& container_id,
	CrostiniManager::GetLinuxPackageInfoCallback callback,
	const LinuxPackageInfo& linux_package_info);

	// Wraps the callback provided in InstallLinuxPackage().
	void OnInstallLinuxPackage(
	const guest_os::GuestId& container_id,
	CrostiniManager::InstallLinuxPackageCallback callback,
	CrostiniResult result);

	// Kicks off an uninstall of the given app. Never queues the operation. Helper
	// for QueueUninstallApplication (if the operation can be performed
	// immediately) and StartQueuedOperation.
	void UninstallApplication(
	const guest_os::GuestOsRegistryService::Registration& registration,
	const std::string& app_id);

	// Callback when the Crostini container is up and ready to accept messages.
	// Used by the uninstall flow only.
	void OnCrostiniRunningForUninstall(const guest_os::GuestId& container_id,
	const std::string& desktop_file_id,
	CrostiniResult result);

	// Callback for CrostiniManager::UninstallPackageOwningFile().
	void OnUninstallPackageOwningFile(const guest_os::GuestId& container_id,
	CrostiniResult result);

	// Kick off the next operation in the queue for the given container.
	void StartQueuedOperation(const guest_os::GuestId& container_id);

	std::string GetUniqueNotificationId();

	raw_ptr<Profile> profile_;

	// The notifications in the RUNNING state for each container.
	std::map<guest_os::GuestId, std::unique_ptr<CrostiniPackageNotification>>
	running_notifications_;

	// Installs we want to run when the current operation is done.
	std::map<guest_os::GuestId, std::queue<QueuedInstall>> queued_installs_;

	// Uninstalls we want to run when the current operation is done.
	std::map<guest_os::GuestId, std::queue<QueuedUninstall>> queued_uninstalls_;

	// Notifications in a finished state (either SUCCEEDED or FAILED). We need
	// to keep notifications around until they are dismissed even if we don't
	// update them any more.
	std::vector<std::unique_ptr<CrostiniPackageNotification>>
	finished_notifications_;

	// A map storing which containers have currently pending app list update
	// operations. If a container is not present in the map, we assume no pending
	// updates.
	std::set<guest_os::GuestId> has_pending_app_list_updates_;

	// Called each time a notification is set to a new state.
	StateChangeCallback testing_state_change_callback_;

	int next_notification_id_ = 0;

	CrostiniManager::RestartId restart_id_for_testing_;

	base::WeakPtrFactory<CrostiniPackageService> weak_ptr_factory_{this};
	};

	} // namespace crostini

	#endif // CHROME_BROWSER_ASH_CROSTINI_CROSTINI_PACKAGE_SERVICE_H_