| // Copyright 2021 The Chromium Authors |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "components/app_restore/app_restore_utils.h" |
| |
| #include "base/functional/bind.h" |
| #include "base/strings/string_number_conversions.h" |
| #include "chromeos/ui/base/app_types.h" |
| #include "chromeos/ui/base/window_properties.h" |
| #include "components/app_constants/constants.h" |
| #include "components/app_restore/app_restore_info.h" |
| #include "components/app_restore/desk_template_read_handler.h" |
| #include "components/app_restore/features.h" |
| #include "components/app_restore/full_restore_read_handler.h" |
| #include "components/app_restore/full_restore_save_handler.h" |
| #include "components/app_restore/restore_data.h" |
| #include "components/app_restore/window_info.h" |
| #include "components/app_restore/window_properties.h" |
| #include "ui/aura/client/aura_constants.h" |
| #include "ui/views/widget/widget_delegate.h" |
| |
| namespace app_restore { |
| namespace { |
| |
| const char kCrxAppPrefix[] = "_crx_"; |
| |
| static int32_t session_id_counter = kArcSessionIdOffsetForRestoredLaunching; |
| |
| } // namespace |
| |
| bool IsArcWindow(aura::Window* window) { |
| return window->GetProperty(chromeos::kAppTypeKey) == |
| chromeos::AppType::ARC_APP; |
| } |
| |
| bool HasWindowInfo(int32_t restore_window_id) { |
| // DeskTemplateReadHandler::GetWindowInfo returns nullptr if |
| // `restore_window_id` is unknown. |
| if (DeskTemplateReadHandler::Get()->GetWindowInfo(restore_window_id)) |
| return true; |
| return full_restore::FullRestoreReadHandler::GetInstance()->HasWindowInfo( |
| restore_window_id); |
| } |
| |
| void ApplyProperties(app_restore::WindowInfo* window_info, |
| ui::PropertyHandler* property_handler) { |
| DCHECK(window_info); |
| DCHECK(property_handler); |
| |
| property_handler->SetProperty(app_restore::kWindowInfoKey, |
| new WindowInfo(*window_info)); |
| |
| if (window_info->activation_index) { |
| const int32_t index = *window_info->activation_index; |
| // kActivationIndexKey is owned, which allows for passing in this raw |
| // pointer. |
| property_handler->SetProperty(app_restore::kActivationIndexKey, |
| std::make_unique<int32_t>(index)); |
| // Windows opened from full restore should not be activated. Widgets that |
| // are shown are activated by default. Force the widget to not be |
| // activatable; the activation will be restored in ash once the window is |
| // launched. |
| property_handler->SetProperty(app_restore::kLaunchedFromAppRestoreKey, |
| true); |
| } |
| if (window_info->pre_minimized_show_state_type) { |
| property_handler->SetProperty(aura::client::kRestoreShowStateKey, |
| *window_info->pre_minimized_show_state_type); |
| } |
| } |
| |
| void ModifyWidgetParams(int32_t restore_window_id, |
| views::Widget::InitParams* out_params) { |
| DCHECK(out_params); |
| |
| const bool is_arc_app = |
| out_params->init_properties_container.GetProperty( |
| chromeos::kAppTypeKey) == chromeos::AppType::ARC_APP; |
| std::unique_ptr<app_restore::WindowInfo> window_info; |
| auto* full_restore_read_handler = |
| full_restore::FullRestoreReadHandler::GetInstance(); |
| auto* desk_template_read_handler = DeskTemplateReadHandler::Get(); |
| if (is_arc_app) { |
| // This will return nullptr if `restore_window_id` doesn't belong to a desk |
| // template launch. In that case, we fall back on full restore. |
| ArcReadHandler* arc_read_handler = |
| desk_template_read_handler->GetArcReadHandlerForWindow( |
| restore_window_id); |
| if (!arc_read_handler) |
| arc_read_handler = full_restore_read_handler->arc_read_handler(); |
| |
| window_info = arc_read_handler |
| ? arc_read_handler->GetWindowInfo(restore_window_id) |
| : nullptr; |
| } else { |
| window_info = desk_template_read_handler->GetWindowInfo(restore_window_id); |
| if (!window_info) { |
| window_info = full_restore_read_handler->GetWindowInfoForActiveProfile( |
| restore_window_id); |
| } |
| } |
| if (!window_info) |
| return; |
| |
| ApplyProperties(window_info.get(), &out_params->init_properties_container); |
| |
| if (window_info->desk_id) { |
| out_params->workspace = base::NumberToString(*window_info->desk_id); |
| } else if (window_info->desk_guid.is_valid()) { |
| out_params->workspace = window_info->desk_guid.AsLowercaseString(); |
| } |
| if (window_info->current_bounds) |
| out_params->bounds = *window_info->current_bounds; |
| if (window_info->window_state_type) { |
| // ToWindowShowState will make us lose some ash-specific types (left/right |
| // snap). Ash is responsible for restoring these states by checking |
| // GetWindowInfo. |
| out_params->show_state = |
| chromeos::ToWindowShowState(*window_info->window_state_type); |
| } |
| |
| // Register to track when the widget has initialized. If a delegate is not |
| // set, then the widget creator is responsible for calling |
| // OnWidgetInitialized. |
| views::WidgetDelegate* delegate = out_params->delegate; |
| if (delegate) { |
| delegate->RegisterWidgetInitializedCallback(base::BindOnce( |
| [](views::WidgetDelegate* delegate) { |
| app_restore::AppRestoreInfo::GetInstance()->OnWidgetInitialized( |
| delegate->GetWidget()); |
| }, |
| delegate)); |
| } |
| } |
| |
| int32_t FetchRestoreWindowId(const std::string& app_id) { |
| // If full restore is running and full restore knows the app_id, then we use |
| // it. Otherwise fall back on desk templates. |
| auto* full_restore_read_handler = |
| full_restore::FullRestoreReadHandler::GetInstance(); |
| |
| int32_t restore_window_id = 0; |
| if (full_restore_read_handler->IsFullRestoreRunning()) |
| restore_window_id = full_restore_read_handler->FetchRestoreWindowId(app_id); |
| |
| if (!restore_window_id) { |
| restore_window_id = |
| DeskTemplateReadHandler::Get()->FetchRestoreWindowId(app_id); |
| } |
| |
| return restore_window_id; |
| } |
| |
| int32_t CreateArcSessionId() { |
| // ARC session id offset start counting from a large number. When the counter |
| // overflow, it will less the start number. |
| if (session_id_counter < kArcSessionIdOffsetForRestoredLaunching) { |
| LOG(WARNING) << "ARC session id is overflow: " << session_id_counter; |
| session_id_counter = kArcSessionIdOffsetForRestoredLaunching; |
| } |
| return ++session_id_counter; |
| } |
| |
| void SetArcSessionIdForWindowId(int32_t arc_session_id, int32_t window_id) { |
| auto* desk_template_read_handler = DeskTemplateReadHandler::Get(); |
| if (desk_template_read_handler->IsKnownArcSessionId(arc_session_id)) { |
| desk_template_read_handler->SetArcSessionIdForWindowId(arc_session_id, |
| window_id); |
| } else { |
| full_restore::FullRestoreReadHandler::GetInstance() |
| ->SetArcSessionIdForWindowId(arc_session_id, window_id); |
| } |
| } |
| |
| void SetDeskTemplateLaunchIdForArcSessionId(int32_t arc_session_id, |
| int32_t desk_template_launch_id) { |
| DeskTemplateReadHandler::Get()->SetLaunchIdForArcSessionId( |
| arc_session_id, desk_template_launch_id); |
| } |
| |
| int32_t GetArcRestoreWindowIdForTaskId(int32_t task_id) { |
| if (int32_t restore_window_id = |
| DeskTemplateReadHandler::Get()->GetArcRestoreWindowIdForTaskId( |
| task_id)) { |
| return restore_window_id; |
| } |
| return full_restore::FullRestoreReadHandler::GetInstance() |
| ->GetArcRestoreWindowIdForTaskId(task_id); |
| } |
| |
| int32_t GetArcRestoreWindowIdForSessionId(int32_t session_id) { |
| if (int32_t restore_window_id = |
| DeskTemplateReadHandler::Get()->GetArcRestoreWindowIdForSessionId( |
| session_id)) { |
| return restore_window_id; |
| } |
| return full_restore::FullRestoreReadHandler::GetInstance() |
| ->GetArcRestoreWindowIdForSessionId(session_id); |
| } |
| |
| std::string GetAppIdFromAppName(const std::string& app_name) { |
| std::string prefix(kCrxAppPrefix); |
| if (app_name.substr(0, prefix.length()) != prefix) |
| return std::string(); |
| return app_name.substr(prefix.length()); |
| } |
| |
| std::tuple<int, int, int> GetWindowAndTabCount( |
| const RestoreData& restore_data) { |
| int window_count = 0; |
| int tab_count = 0; |
| int total_count = 0; |
| |
| const RestoreData::AppIdToLaunchList& launch_list_map = |
| restore_data.app_id_to_launch_list(); |
| for (const auto& [app_id, launch_list] : launch_list_map) { |
| for (const auto& [window_id, app_restore_data] : launch_list) { |
| const std::vector<GURL>& urls = app_restore_data->browser_extra_info.urls; |
| // Url field could be empty if the app is not the browser, or if from full |
| // restore. We check the app type also in case the url field is not set up |
| // correctly. |
| if (urls.empty() || app_id != app_constants::kChromeAppId) { |
| ++window_count; |
| ++total_count; |
| continue; |
| } |
| |
| ++window_count; |
| tab_count += urls.size(); |
| total_count += urls.size(); |
| } |
| } |
| |
| return std::make_tuple(window_count, tab_count, total_count); |
| } |
| |
| } // namespace app_restore |
