| // Copyright 2020 The Chromium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #ifndef COMPONENTS_APP_RESTORE_FULL_RESTORE_READ_HANDLER_H_ |
| #define COMPONENTS_APP_RESTORE_FULL_RESTORE_READ_HANDLER_H_ |
| |
| #include <memory> |
| #include <utility> |
| |
| #include "base/callback.h" |
| #include "base/component_export.h" |
| #include "base/containers/flat_map.h" |
| #include "base/files/file_path.h" |
| #include "base/memory/weak_ptr.h" |
| #include "base/scoped_multi_source_observation.h" |
| #include "base/scoped_observation.h" |
| #include "base/time/time.h" |
| #include "components/app_restore/app_restore_arc_info.h" |
| #include "components/app_restore/arc_read_handler.h" |
| #include "components/app_restore/full_restore_utils.h" |
| #include "ui/aura/env.h" |
| #include "ui/aura/env_observer.h" |
| #include "ui/aura/window.h" |
| #include "ui/aura/window_observer.h" |
| |
| namespace app_restore { |
| struct AppLaunchInfo; |
| class LacrosReadHandler; |
| class RestoreData; |
| struct WindowInfo; |
| } // namespace app_restore |
| |
| namespace ash { |
| namespace full_restore { |
| class FullRestoreAppLaunchHandlerBrowserTest; |
| class FullRestoreAppLaunchHandlerSystemWebAppsBrowserTest; |
| class FullRestoreServiceTestHavingFullRestoreFile; |
| } // namespace full_restore |
| } // namespace ash |
| |
| namespace full_restore { |
| |
| class FullRestoreFileHandler; |
| |
| // FullRestoreReadHandler is responsible for reading |RestoreData| from the full |
| // restore data file. FullRestoreReadHandler runs on the main thread and creates |
| // FullRestoreFileHandler (which runs on a background task runner) for the |
| // actual reading. |
| class COMPONENT_EXPORT(APP_RESTORE) FullRestoreReadHandler |
| : public aura::EnvObserver, |
| public aura::WindowObserver, |
| public app_restore::ArcReadHandler::Delegate, |
| public app_restore::AppRestoreArcInfo::Observer { |
| public: |
| // The callback function to get the restore data when the reading operation is |
| // done. |
| using Callback = |
| base::OnceCallback<void(std::unique_ptr<app_restore::RestoreData>)>; |
| |
| static FullRestoreReadHandler* GetInstance(); |
| |
| FullRestoreReadHandler(); |
| FullRestoreReadHandler(const FullRestoreReadHandler&) = delete; |
| FullRestoreReadHandler& operator=(const FullRestoreReadHandler&) = delete; |
| ~FullRestoreReadHandler() override; |
| |
| app_restore::ArcReadHandler* arc_read_handler() { |
| return arc_read_handler_.get(); |
| } |
| |
| // aura::EnvObserver: |
| void OnWindowInitialized(aura::Window* window) override; |
| |
| // aura::WindowObserver: |
| void OnWindowAddedToRootWindow(aura::Window* window) override; |
| void OnWindowDestroyed(aura::Window* window) override; |
| |
| // app_restore::ArcReadHandler::Delegate: |
| std::unique_ptr<app_restore::AppLaunchInfo> GetAppLaunchInfo( |
| const base::FilePath& profile_path, |
| const std::string& app_id, |
| int32_t restore_window_id) override; |
| std::unique_ptr<app_restore::WindowInfo> GetWindowInfo( |
| const base::FilePath& profile_path, |
| const std::string& app_id, |
| int32_t restore_window_id) override; |
| void RemoveAppRestoreData(const base::FilePath& profile_path, |
| const std::string& app_id, |
| int32_t restore_window_id) override; |
| |
| // app_restore::AppRestoreArcInfo::Observer: |
| void OnTaskCreated(const std::string& app_id, |
| int32_t task_id, |
| int32_t session_id) override; |
| void OnTaskDestroyed(int32_t task_id) override; |
| |
| // Invoked when an Chrome app Lacros window is created. `app_id` is the |
| // AppService id, and `window_id` is the wayland app_id property for the |
| // window. |
| void OnLacrosChromeAppWindowAdded(const std::string& app_id, |
| const std::string& window_id); |
| |
| // Invoked when an Chrome app Lacros window is removed. `app_id` is the |
| // AppService id, and `window_id` is the wayland app_id property for the |
| // window. |
| void OnLacrosChromeAppWindowRemoved(const std::string& app_id, |
| const std::string& window_id); |
| |
| void SetPrimaryProfilePath(const base::FilePath& profile_path); |
| |
| void SetActiveProfilePath(const base::FilePath& profile_path); |
| |
| // Sets whether we should check the restore data for `profile_path`. If the |
| // user selects `Restore`, then we should check the restore data for restored |
| // windows. Otherwise, we don't need to to check the restore data. |
| void SetCheckRestoreData(const base::FilePath& profile_path); |
| |
| // Reads the restore data from |profile_path| on a background task runner, and |
| // calls |callback| when the reading operation is done. |
| void ReadFromFile(const base::FilePath& profile_path, Callback callback); |
| |
| // Modifies the restore data from |profile_path| to set the next restore |
| // window id for the given chrome app |app_id|. |
| void SetNextRestoreWindowIdForChromeApp(const base::FilePath& profile_path, |
| const std::string& app_id); |
| |
| // Removes app launching and app windows for an app with the given |app_id| |
| // from |profile_path_to_restore_data_| for |profile_path| . |
| void RemoveApp(const base::FilePath& profile_path, const std::string& app_id); |
| |
| // Returns true if there are app type browsers from the full restore file. |
| // Otherwise, returns false. |
| bool HasAppTypeBrowser(const base::FilePath& profile_path); |
| |
| // Returns true if there are normal browsers (non app type browser) from the |
| // full restore file. Otherwise, returns false. |
| bool HasBrowser(const base::FilePath& profile_path); |
| |
| // Returns true if there is a window info for |restore_window_id| from the |
| // full restore file. Otherwise, returns false. This interface can't be used |
| // for Arc app windows. |
| bool HasWindowInfo(int32_t restore_window_id); |
| |
| // Gets the window information for |window|. |
| std::unique_ptr<app_restore::WindowInfo> GetWindowInfo(aura::Window* window); |
| |
| // Gets the window information for the active profile associated with |
| // `restore_window_id`. |
| std::unique_ptr<app_restore::WindowInfo> GetWindowInfoForActiveProfile( |
| int32_t restore_window_id); |
| |
| // Gets the ARC app launch information from the full restore file for `app_id` |
| // and `session_id`. |
| std::unique_ptr<app_restore::AppLaunchInfo> GetArcAppLaunchInfo( |
| const std::string& app_id, |
| int32_t session_id); |
| |
| // Fetches the restore id for the window from RestoreData for the given |
| // |app_id|. |app_id| should be a Chrome app id. |
| int32_t FetchRestoreWindowId(const std::string& app_id); |
| |
| // Returns the restore window id for the ARC app's |task_id|. |
| int32_t GetArcRestoreWindowIdForTaskId(int32_t task_id); |
| |
| // Returns the restore window id for the ARC app's |session_id|. |
| int32_t GetArcRestoreWindowIdForSessionId(int32_t session_id); |
| |
| // Returns the restore window id for the Lacros window with |
| // `lacros_window_id`. |
| int32_t GetLacrosRestoreWindowId(const std::string& lacros_window_id) const; |
| |
| // Sets |arc session id| for |window_id| to |arc_session_id_to_window_id_|. |
| // |arc session id| is assigned when ARC apps are restored. |
| void SetArcSessionIdForWindowId(int32_t arc_session_id, int32_t window_id); |
| |
| // Called when full restore launching is about to begin. Saves the start time |
| // in `profile_path_to_start_time_data_`. |
| void SetStartTimeForProfile(const base::FilePath& profile_path); |
| |
| // Returns true if full restore launching is thought to be underway on |
| // `active_profile_path_`. |
| bool IsFullRestoreRunning() const; |
| |
| void AddChromeBrowserLaunchInfoForTesting(const base::FilePath& profile_path); |
| |
| private: |
| friend class ash::full_restore::FullRestoreAppLaunchHandlerBrowserTest; |
| friend class ash::full_restore:: |
| FullRestoreAppLaunchHandlerSystemWebAppsBrowserTest; |
| friend class ash::full_restore::FullRestoreServiceTestHavingFullRestoreFile; |
| friend class FullRestoreReadHandlerTestApi; |
| |
| // Gets the window information for |restore_window_id| for browser windows and |
| // Chrome app windows only. This interface can't be used for ARC app windows. |
| std::unique_ptr<app_restore::WindowInfo> GetWindowInfo( |
| int32_t restore_window_id); |
| |
| // Returns true if ARC restore launching is thought to be underway on |
| // `primary_profile_path_`. |
| bool IsArcRestoreRunning() const; |
| |
| // Returns true if Lacros restore launching is thought to be underway on |
| // `primary_profile_path_`. |
| bool IsLacrosRestoreRunning() const; |
| |
| // Invoked when reading the restore data from |profile_path| is finished, and |
| // calls |callback| to notify that the reading operation is done. |
| void OnGetRestoreData(const base::FilePath& profile_path, |
| Callback callback, |
| std::unique_ptr<app_restore::RestoreData>); |
| |
| // Removes AppRestoreData for |restore_window_id|. |
| void RemoveAppRestoreData(int32_t restore_window_id); |
| |
| app_restore::RestoreData* GetRestoreData(const base::FilePath& profile_path); |
| |
| // The primary user profile path. |
| base::FilePath primary_profile_path_; |
| |
| // The current active user profile path. |
| base::FilePath active_profile_path_; |
| |
| // The restore data read from the full restore files. |
| base::flat_map<base::FilePath, std::unique_ptr<app_restore::RestoreData>> |
| profile_path_to_restore_data_; |
| |
| // The map from the window id to the full restore file path and the |
| // app id. The window id is saved in the window property |
| // |kRestoreWindowIdKey|. This map is used to find the file path and the app |
| // id when get the window info. This map is not used for ARC app windows. |
| base::flat_map<int32_t, std::pair<base::FilePath, std::string>> |
| window_id_to_app_restore_info_; |
| |
| // The start time of full restore for each profile. There won't be an entry if |
| // full restore hasn't started for the profile. |
| base::flat_map<base::FilePath, base::TimeTicks> |
| profile_path_to_start_time_data_; |
| |
| std::unique_ptr<app_restore::ArcReadHandler> arc_read_handler_; |
| |
| std::unique_ptr<app_restore::LacrosReadHandler> lacros_read_handler_; |
| |
| // Records whether we need to check the restore data for the profile path. If |
| // the profile path is recorded, we should check the restore data. Otherwise, |
| // we don't need to check the restore data, because the restore process hasn't |
| // started yet. |
| std::set<base::FilePath> should_check_restore_data_; |
| |
| base::ScopedObservation<aura::Env, aura::EnvObserver> env_observer_{this}; |
| |
| base::ScopedMultiSourceObservation<aura::Window, aura::WindowObserver> |
| observed_windows_{this}; |
| |
| base::ScopedObservation<app_restore::AppRestoreArcInfo, |
| app_restore::AppRestoreArcInfo::Observer> |
| arc_info_observer_{this}; |
| |
| base::WeakPtrFactory<FullRestoreReadHandler> weak_factory_{this}; |
| }; |
| |
| } // namespace full_restore |
| |
| #endif // COMPONENTS_APP_RESTORE_FULL_RESTORE_READ_HANDLER_H_ |