// Copyright 2020 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/restore_data.h"
#include <cstdint>
#include <memory>
#include <optional>
#include <utility>
#include "base/containers/contains.h"
#include "base/values.h"
#include "chromeos/ui/base/window_state_type.h"
#include "components/app_constants/constants.h"
#include "components/app_restore/app_launch_info.h"
#include "components/app_restore/app_restore_data.h"
#include "components/app_restore/window_info.h"
#include "components/services/app_service/public/cpp/app_launch_util.h"
#include "components/services/app_service/public/cpp/intent.h"
#include "components/tab_groups/tab_group_color.h"
#include "components/tab_groups/tab_group_info.h"
#include "components/tab_groups/tab_group_visual_data.h"
#include "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "ui/aura/client/aura_constants.h"
#include "ui/base/window_open_disposition.h"
#include "ui/gfx/geometry/rect.h"
namespace app_restore {
namespace {
using testing::ElementsAre;
using testing::Pair;
constexpr char kAppId1[] = "aaa";
constexpr char kAppId2[] = "bbb";
constexpr int32_t kWindowId1 = 100;
constexpr int32_t kWindowId2 = 200;
constexpr int32_t kWindowId3 = 300;
constexpr int32_t kWindowId4 = 400;
constexpr int64_t kDisplayId1 = 22000000;
constexpr int64_t kDisplayId2 = 11000000;
constexpr char kFilePath1[] = "path1";
constexpr char kFilePath2[] = "path2";
constexpr char kIntentActionView[] = "view";
constexpr char kIntentActionSend[] = "send";
constexpr bool kAppTypeBrower1 = false;
constexpr bool kAppTypeBrower2 = true;
constexpr bool kAppTypeBrower3 = false;
constexpr char kMimeType[] = "text/plain";
constexpr char kShareText1[] = "text1";
constexpr char kShareText2[] = "text2";
constexpr int32_t kActivationIndex1 = 100;
constexpr int32_t kActivationIndex2 = 101;
constexpr int32_t kActivationIndex3 = 102;
constexpr int32_t kFirstNonPinnedTabIndex = 1;
constexpr int32_t kDeskId1 = 1;
constexpr int32_t kDeskId2 = 2;
constexpr int32_t kDeskId3 =
aura::client::kWindowWorkspaceVisibleOnAllWorkspaces;
const base::Uuid kDeskGuid1 = base::Uuid::GenerateRandomV4();
const base::Uuid kDeskGuid2 = base::Uuid::GenerateRandomV4();
const base::Uuid kDeskGuid3 = base::Uuid();
constexpr gfx::Rect kCurrentBounds1(11, 21, 111, 121);
constexpr gfx::Rect kCurrentBounds2(31, 41, 131, 141);
constexpr gfx::Rect kCurrentBounds3(51, 61, 151, 161);
constexpr chromeos::WindowStateType kWindowStateType1 =
chromeos::WindowStateType::kMaximized;
constexpr chromeos::WindowStateType kWindowStateType2 =
chromeos::WindowStateType::kMinimized;
constexpr chromeos::WindowStateType kWindowStateType3 =
chromeos::WindowStateType::kPrimarySnapped;
constexpr ui::WindowShowState kPreMinimizedWindowStateType1 =
ui::SHOW_STATE_DEFAULT;
constexpr ui::WindowShowState kPreMinimizedWindowStateType2 =
ui::SHOW_STATE_MAXIMIZED;
constexpr ui::WindowShowState kPreMinimizedWindowStateType3 =
ui::SHOW_STATE_DEFAULT;
constexpr int32_t kSnapPercentage = 75;
constexpr gfx::Size kMaxSize1(600, 800);
constexpr gfx::Size kMinSize1(100, 50);
constexpr gfx::Size kMinSize2(88, 128);
constexpr uint32_t kPrimaryColor1(0xFFFFFFFF);
constexpr uint32_t kPrimaryColor2(0xFF000000);
constexpr uint32_t kStatusBarColor1(0xFF00FF00);
constexpr uint32_t kStatusBarColor2(0xFF000000);
constexpr char16_t kTitle1[] = u"test title1";
constexpr char16_t kTitle2[] = u"test title2";
constexpr gfx::Rect kBoundsInRoot1(11, 21, 111, 121);
constexpr gfx::Rect kBoundsInRoot2(31, 41, 131, 141);
constexpr char16_t kTestTabGroupTitleOne[] = u"sample_tab_group_1";
constexpr char16_t kTestTabGroupTitleTwo[] = u"sample_tab_group_2";
constexpr char16_t kTestTabGroupTitleThree[] = u"sample_tab_group_3";
const tab_groups::TabGroupColorId kTestTabGroupColorOne =
tab_groups::TabGroupColorId::kGrey;
const tab_groups::TabGroupColorId kTestTabGroupColorTwo =
tab_groups::TabGroupColorId::kBlue;
const tab_groups::TabGroupColorId kTestTabGroupColorThree =
tab_groups::TabGroupColorId::kGreen;
const gfx::Range kTestTabGroupTabRange(1, 2);
tab_groups::TabGroupInfo MakeTestTabGroup(const char16_t* title,
tab_groups::TabGroupColorId color) {
return tab_groups::TabGroupInfo(kTestTabGroupTabRange,
tab_groups::TabGroupVisualData(title, color));
}
void PopulateTestTabgroups(
std::vector<tab_groups::TabGroupInfo>& out_tab_groups) {
out_tab_groups.push_back(
MakeTestTabGroup(kTestTabGroupTitleOne, kTestTabGroupColorOne));
out_tab_groups.push_back(
MakeTestTabGroup(kTestTabGroupTitleTwo, kTestTabGroupColorTwo));
out_tab_groups.push_back(
MakeTestTabGroup(kTestTabGroupTitleThree, kTestTabGroupColorThree));
}
} // namespace
// Unit tests for restore data.
class RestoreDataTest : public testing::Test {
public:
RestoreDataTest() = default;
RestoreDataTest(const RestoreDataTest&) = delete;
RestoreDataTest& operator=(const RestoreDataTest&) = delete;
~RestoreDataTest() override = default;
apps::IntentPtr MakeIntent(const std::string& action,
const std::string& mime_type,
const std::string& share_text) {
auto intent = std::make_unique<apps::Intent>(action);
intent->mime_type = mime_type;
intent->share_text = share_text;
return intent;
}
void AddAppLaunchInfos() {
auto app_launch_info1 = std::make_unique<AppLaunchInfo>(
kAppId1, kWindowId1, apps::LaunchContainer::kLaunchContainerWindow,
WindowOpenDisposition::NEW_WINDOW, kDisplayId1,
std::vector<base::FilePath>{base::FilePath(kFilePath1),
base::FilePath(kFilePath2)},
MakeIntent(kIntentActionSend, kMimeType, kShareText1));
auto app_launch_info2 = std::make_unique<AppLaunchInfo>(
kAppId1, kWindowId2, apps::LaunchContainer::kLaunchContainerTab,
WindowOpenDisposition::NEW_FOREGROUND_TAB, kDisplayId2,
std::vector<base::FilePath>{base::FilePath(kFilePath2)},
MakeIntent(kIntentActionView, kMimeType, kShareText2));
app_launch_info2->browser_extra_info.app_type_browser = kAppTypeBrower2;
app_launch_info2->browser_extra_info.first_non_pinned_tab_index =
kFirstNonPinnedTabIndex;
PopulateTestTabgroups(app_launch_info2->browser_extra_info.tab_group_infos);
auto app_launch_info3 = std::make_unique<AppLaunchInfo>(
kAppId2, kWindowId3, apps::LaunchContainer::kLaunchContainerNone,
WindowOpenDisposition::NEW_POPUP, kDisplayId2,
std::vector<base::FilePath>{base::FilePath(kFilePath1)},
MakeIntent(kIntentActionView, kMimeType, kShareText1));
restore_data().AddAppLaunchInfo(std::move(app_launch_info1));
restore_data().AddAppLaunchInfo(std::move(app_launch_info2));
restore_data().AddAppLaunchInfo(std::move(app_launch_info3));
}
void ModifyWindowInfos() {
WindowInfo window_info1;
window_info1.activation_index = kActivationIndex1;
window_info1.desk_id = kDeskId1;
window_info1.desk_guid = kDeskGuid1;
window_info1.current_bounds = kCurrentBounds1;
window_info1.window_state_type = kWindowStateType1;
window_info1.display_id = kDisplayId2;
window_info1.app_title = kTitle1;
window_info1.arc_extra_info = {.maximum_size = kMaxSize1,
.minimum_size = kMinSize1,
.bounds_in_root = kBoundsInRoot1};
WindowInfo window_info2;
window_info2.activation_index = kActivationIndex2;
window_info2.desk_id = kDeskId2;
window_info2.desk_guid = kDeskGuid2;
window_info2.current_bounds = kCurrentBounds2;
window_info2.window_state_type = kWindowStateType2;
window_info2.pre_minimized_show_state_type = kPreMinimizedWindowStateType2;
window_info2.display_id = kDisplayId1;
window_info2.app_title = kTitle2;
window_info2.arc_extra_info = {.minimum_size = kMinSize2,
.bounds_in_root = kBoundsInRoot2};
WindowInfo window_info3;
window_info3.activation_index = kActivationIndex3;
window_info3.desk_id = kDeskId3;
window_info3.desk_guid = kDeskGuid3;
window_info3.current_bounds = kCurrentBounds3;
window_info3.window_state_type = kWindowStateType3;
window_info3.snap_percentage = kSnapPercentage;
window_info3.display_id = kDisplayId1;
restore_data().ModifyWindowInfo(kAppId1, kWindowId1, window_info1);
restore_data().ModifyWindowInfo(kAppId1, kWindowId2, window_info2);
restore_data().ModifyWindowInfo(kAppId2, kWindowId3, window_info3);
}
void ModifyThemeColors() {
restore_data().ModifyThemeColor(kAppId1, kWindowId1, kPrimaryColor1,
kStatusBarColor1);
restore_data().ModifyThemeColor(kAppId1, kWindowId2, kPrimaryColor2,
kStatusBarColor2);
}
void VerifyAppRestoreData(
const std::unique_ptr<AppRestoreData>& data,
apps::LaunchContainer container,
WindowOpenDisposition disposition,
int64_t display_id,
std::vector<base::FilePath> file_paths,
apps::IntentPtr intent,
bool app_type_browser,
int32_t activation_index,
int32_t first_non_pinned_tab_index,
int32_t desk_id,
const base::Uuid& desk_guid,
const gfx::Rect& current_bounds,
chromeos::WindowStateType window_state_type,
ui::WindowShowState pre_minimized_show_state_type,
uint32_t snap_percentage,
std::optional<gfx::Size> max_size,
std::optional<gfx::Size> min_size,
std::optional<std::u16string> title,
std::optional<gfx::Rect> bounds_in_root,
uint32_t primary_color,
uint32_t status_bar_color,
std::vector<tab_groups::TabGroupInfo> expected_tab_group_infos,
bool test_tab_group_infos = true) {
EXPECT_THAT(data->container,
testing::Optional(static_cast<int>(container)));
EXPECT_THAT(data->disposition,
testing::Optional(static_cast<int>(disposition)));
EXPECT_THAT(data->display_id, testing::Optional(display_id));
EXPECT_EQ(file_paths, data->file_paths);
EXPECT_TRUE(data->intent);
EXPECT_EQ(intent->action, data->intent->action);
EXPECT_EQ(intent->mime_type, data->intent->mime_type);
EXPECT_EQ(intent->share_text, data->intent->share_text);
const BrowserExtraInfo browser_info = data->browser_extra_info;
if (!app_type_browser) {
// This field should only be written if it is true.
EXPECT_FALSE(browser_info.app_type_browser.has_value());
} else {
EXPECT_THAT(browser_info.app_type_browser,
testing::Optional(app_type_browser));
EXPECT_THAT(browser_info.first_non_pinned_tab_index,
testing::Optional(first_non_pinned_tab_index));
}
const WindowInfo window_info = data->window_info;
EXPECT_THAT(window_info.activation_index,
testing::Optional(activation_index));
EXPECT_THAT(window_info.desk_id, testing::Optional(desk_id));
EXPECT_EQ(desk_guid, window_info.desk_guid);
EXPECT_THAT(window_info.current_bounds, testing::Optional(current_bounds));
EXPECT_THAT(window_info.window_state_type,
testing::Optional(window_state_type));
// This field should only be written if we are in minimized window state.
if (window_info.window_state_type.value() ==
chromeos::WindowStateType::kMinimized) {
EXPECT_THAT(window_info.pre_minimized_show_state_type,
testing::Optional(pre_minimized_show_state_type));
}
// This field should only be written if we are snapped.
if (chromeos::IsSnappedWindowStateType(
window_info.window_state_type.value())) {
EXPECT_THAT(window_info.snap_percentage,
testing::Optional(snap_percentage));
}
EXPECT_EQ(title, window_info.app_title);
// Extra ARC window's information.
if (max_size || min_size || bounds_in_root) {
ASSERT_TRUE(window_info.arc_extra_info.has_value());
EXPECT_EQ(max_size, window_info.arc_extra_info->maximum_size);
EXPECT_EQ(min_size, window_info.arc_extra_info->minimum_size);
EXPECT_EQ(bounds_in_root, window_info.arc_extra_info->bounds_in_root);
}
if (primary_color) {
EXPECT_THAT(data->primary_color, testing::Optional(primary_color));
} else {
EXPECT_FALSE(data->primary_color.has_value());
}
if (status_bar_color) {
EXPECT_THAT(data->status_bar_color, testing::Optional(status_bar_color));
} else {
EXPECT_FALSE(data->status_bar_color.has_value());
}
// Only test tab group infos in tests that don't concern serialization
// or deserialization as the logic for serializing tab group infos exists in
// the desks_storage component. This is because tab group infos are only
// utilized by save and recall and desk template features.
if (expected_tab_group_infos.size() > 0 && test_tab_group_infos) {
// If we're passing a non-empty expected vector then we expect the object
// under test to have tab group infos.
EXPECT_FALSE(browser_info.tab_group_infos.empty());
EXPECT_THAT(browser_info.tab_group_infos,
testing::UnorderedElementsAreArray(expected_tab_group_infos));
}
}
void VerifyRestoreData(const RestoreData& restore_data,
bool test_tab_group_infos = true) {
EXPECT_EQ(2u, app_id_to_launch_list(restore_data).size());
// Verify for |kAppId1|.
const auto launch_list_it1 =
app_id_to_launch_list(restore_data).find(kAppId1);
EXPECT_TRUE(launch_list_it1 != app_id_to_launch_list(restore_data).end());
EXPECT_EQ(2u, launch_list_it1->second.size());
const auto app_restore_data_it1 = launch_list_it1->second.find(kWindowId1);
EXPECT_TRUE(app_restore_data_it1 != launch_list_it1->second.end());
VerifyAppRestoreData(
app_restore_data_it1->second,
apps::LaunchContainer::kLaunchContainerWindow,
WindowOpenDisposition::NEW_WINDOW, kDisplayId2,
std::vector<base::FilePath>{base::FilePath(kFilePath1),
base::FilePath(kFilePath2)},
MakeIntent(kIntentActionSend, kMimeType, kShareText1), kAppTypeBrower1,
kActivationIndex1, kFirstNonPinnedTabIndex, kDeskId1, kDeskGuid1,
kCurrentBounds1, kWindowStateType1, kPreMinimizedWindowStateType1,
/*snap_percentage=*/0, kMaxSize1, kMinSize1, std::u16string(kTitle1),
kBoundsInRoot1, kPrimaryColor1, kStatusBarColor1,
/*expected_tab_group_infos=*/{});
const auto app_restore_data_it2 = launch_list_it1->second.find(kWindowId2);
std::vector<tab_groups::TabGroupInfo> expected_tab_group_infos;
PopulateTestTabgroups(expected_tab_group_infos);
EXPECT_TRUE(app_restore_data_it2 != launch_list_it1->second.end());
VerifyAppRestoreData(
app_restore_data_it2->second,
apps::LaunchContainer::kLaunchContainerTab,
WindowOpenDisposition::NEW_FOREGROUND_TAB, kDisplayId1,
std::vector<base::FilePath>{base::FilePath(kFilePath2)},
MakeIntent(kIntentActionView, kMimeType, kShareText2), kAppTypeBrower2,
kActivationIndex2, kFirstNonPinnedTabIndex, kDeskId2, kDeskGuid2,
kCurrentBounds2, kWindowStateType2, kPreMinimizedWindowStateType2,
/*snap_percentage=*/0, std::nullopt, kMinSize2, std::u16string(kTitle2),
kBoundsInRoot2, kPrimaryColor2, kStatusBarColor2,
std::move(expected_tab_group_infos), test_tab_group_infos);
// Verify for |kAppId2|.
const auto launch_list_it2 =
app_id_to_launch_list(restore_data).find(kAppId2);
EXPECT_TRUE(launch_list_it2 != app_id_to_launch_list(restore_data).end());
EXPECT_EQ(1u, launch_list_it2->second.size());
EXPECT_EQ(kWindowId3, launch_list_it2->second.begin()->first);
VerifyAppRestoreData(
launch_list_it2->second.begin()->second,
apps::LaunchContainer::kLaunchContainerNone,
WindowOpenDisposition::NEW_POPUP, kDisplayId1,
std::vector<base::FilePath>{base::FilePath(kFilePath1)},
MakeIntent(kIntentActionView, kMimeType, kShareText1), kAppTypeBrower3,
kActivationIndex3, kFirstNonPinnedTabIndex, kDeskId3, kDeskGuid3,
kCurrentBounds3, kWindowStateType3, kPreMinimizedWindowStateType3,
kSnapPercentage, std::nullopt, std::nullopt, std::nullopt, std::nullopt,
0, 0,
/*expected_tab_group_infos=*/{});
}
RestoreData& restore_data() { return restore_data_; }
const RestoreData::AppIdToLaunchList& app_id_to_launch_list() const {
return restore_data_.app_id_to_launch_list();
}
const RestoreData::AppIdToLaunchList& app_id_to_launch_list(
const RestoreData& restore_data) const {
return restore_data.app_id_to_launch_list();
}
private:
RestoreData restore_data_;
};
TEST_F(RestoreDataTest, AddNullAppLaunchInfo) {
restore_data().AddAppLaunchInfo(nullptr);
EXPECT_TRUE(app_id_to_launch_list().empty());
}
TEST_F(RestoreDataTest, AddAppLaunchInfos) {
AddAppLaunchInfos();
ModifyWindowInfos();
ModifyThemeColors();
VerifyRestoreData(restore_data());
}
// Modify the window id from `kWindowId2` to `kWindowId4` for `kAppId1`. Verify
// the restore data is correctly updated.
TEST_F(RestoreDataTest, ModifyWindowId) {
AddAppLaunchInfos();
ModifyWindowInfos();
ModifyThemeColors();
VerifyRestoreData(restore_data());
restore_data().ModifyWindowId(kAppId1, kWindowId2, kWindowId4);
// Verify for |kAppId1|.
const auto launch_list_it1 =
app_id_to_launch_list(restore_data()).find(kAppId1);
EXPECT_TRUE(launch_list_it1 != app_id_to_launch_list(restore_data()).end());
EXPECT_EQ(2u, launch_list_it1->second.size());
// Verify the restore data for |kAppId1| and |kWindowId1| still exists.
EXPECT_TRUE(base::Contains(launch_list_it1->second, kWindowId1));
// Verify the restore data for |kAppId1| and |kWindowId2| doesn't exist.
EXPECT_FALSE(base::Contains(launch_list_it1->second, kWindowId2));
// Verify the restore data for |kWindowId2| is migrated to |kWindowId4|.
const auto app_restore_data_it4 = launch_list_it1->second.find(kWindowId4);
EXPECT_TRUE(app_restore_data_it4 != launch_list_it1->second.end());
VerifyAppRestoreData(
app_restore_data_it4->second, apps::LaunchContainer::kLaunchContainerTab,
WindowOpenDisposition::NEW_FOREGROUND_TAB, kDisplayId1,
std::vector<base::FilePath>{base::FilePath(kFilePath2)},
MakeIntent(kIntentActionView, kMimeType, kShareText2), kAppTypeBrower2,
kActivationIndex2, kFirstNonPinnedTabIndex, kDeskId2, kDeskGuid2,
kCurrentBounds2, kWindowStateType2, kPreMinimizedWindowStateType2,
/*snap_percentage=*/0, std::nullopt, kMinSize2, std::u16string(kTitle2),
kBoundsInRoot2, kPrimaryColor2, kStatusBarColor2,
/*expected_tab_group_infos=*/{});
// Verify the restore data for |kAppId2| still exists.
const auto launch_list_it2 =
app_id_to_launch_list(restore_data()).find(kAppId2);
EXPECT_TRUE(launch_list_it2 != app_id_to_launch_list(restore_data()).end());
EXPECT_EQ(1u, launch_list_it2->second.size());
}
TEST_F(RestoreDataTest, RemoveAppRestoreData) {
AddAppLaunchInfos();
ModifyWindowInfos();
ModifyThemeColors();
VerifyRestoreData(restore_data());
EXPECT_TRUE(restore_data().HasAppRestoreData(kAppId1, kWindowId1));
// Remove `kAppId1`'s `kWindowId1`.
restore_data().RemoveAppRestoreData(kAppId1, kWindowId1);
EXPECT_FALSE(restore_data().HasAppRestoreData(kAppId1, kWindowId1));
EXPECT_EQ(2u, app_id_to_launch_list().size());
// Verify for |kAppId1|.
auto launch_list_it1 = app_id_to_launch_list().find(kAppId1);
EXPECT_TRUE(launch_list_it1 != app_id_to_launch_list().end());
EXPECT_EQ(1u, launch_list_it1->second.size());
EXPECT_FALSE(base::Contains(launch_list_it1->second, kWindowId1));
EXPECT_TRUE(base::Contains(launch_list_it1->second, kWindowId2));
// Verify for |kAppId2|.
auto launch_list_it2 = app_id_to_launch_list().find(kAppId2);
EXPECT_TRUE(launch_list_it2 != app_id_to_launch_list().end());
EXPECT_EQ(1u, launch_list_it2->second.size());
EXPECT_TRUE(base::Contains(launch_list_it2->second, kWindowId3));
EXPECT_TRUE(restore_data().HasAppRestoreData(kAppId1, kWindowId2));
// Remove kAppId1's kWindowId2.
restore_data().RemoveAppRestoreData(kAppId1, kWindowId2);
EXPECT_FALSE(restore_data().HasAppRestoreData(kAppId1, kWindowId2));
EXPECT_EQ(1u, app_id_to_launch_list().size());
// Verify for |kAppId1|.
EXPECT_FALSE(base::Contains(app_id_to_launch_list(), kAppId1));
// Verify for |kAppId2|.
launch_list_it2 = app_id_to_launch_list().find(kAppId2);
EXPECT_TRUE(launch_list_it2 != app_id_to_launch_list().end());
EXPECT_EQ(1u, launch_list_it2->second.size());
EXPECT_TRUE(base::Contains(launch_list_it2->second, kWindowId3));
EXPECT_TRUE(restore_data().HasAppRestoreData(kAppId2, kWindowId3));
// Remove kAppId2's kWindowId3.
restore_data().RemoveAppRestoreData(kAppId2, kWindowId3);
EXPECT_FALSE(restore_data().HasAppRestoreData(kAppId2, kWindowId3));
EXPECT_EQ(0u, app_id_to_launch_list().size());
}
TEST_F(RestoreDataTest, SendWindowToBackground) {
AddAppLaunchInfos();
ModifyWindowInfos();
ModifyThemeColors();
VerifyRestoreData(restore_data());
restore_data().SendWindowToBackground(kAppId1, kWindowId1);
auto window_info = restore_data().GetWindowInfo(kAppId1, kWindowId1);
ASSERT_TRUE(window_info);
EXPECT_THAT(window_info->activation_index, testing::Optional(INT32_MAX));
EXPECT_TRUE(window_info->desk_id.has_value());
EXPECT_TRUE(window_info->desk_guid.is_valid());
EXPECT_TRUE(window_info->current_bounds.has_value());
EXPECT_TRUE(window_info->window_state_type.has_value());
EXPECT_TRUE(window_info->arc_extra_info.has_value());
}
TEST_F(RestoreDataTest, RemoveApp) {
AddAppLaunchInfos();
ModifyWindowInfos();
ModifyThemeColors();
VerifyRestoreData(restore_data());
// Remove `kAppId1`.
restore_data().RemoveApp(kAppId1);
// Verify for `kAppId2`.
EXPECT_THAT(
app_id_to_launch_list(),
ElementsAre(Pair(kAppId2, ElementsAre(Pair(kWindowId3, testing::_)))));
// Remove kAppId2.
restore_data().RemoveApp(kAppId2);
EXPECT_TRUE(app_id_to_launch_list().empty());
}
TEST_F(RestoreDataTest, Convert) {
AddAppLaunchInfos();
ModifyWindowInfos();
ModifyThemeColors();
auto restore_data =
std::make_unique<RestoreData>(this->restore_data().ConvertToValue());
// Full restore is not responsible for serializing or deserializing
// TabGroupInfos.
VerifyRestoreData(*restore_data, /*test_tab_group_infos=*/false);
}
TEST_F(RestoreDataTest, ConvertNullData) {
restore_data().AddAppLaunchInfo(nullptr);
EXPECT_TRUE(app_id_to_launch_list().empty());
auto restore_data =
std::make_unique<RestoreData>(this->restore_data().ConvertToValue());
EXPECT_TRUE(app_id_to_launch_list(*restore_data).empty());
}
TEST_F(RestoreDataTest, GetAppLaunchInfo) {
// The app id and window id doesn't exist.
auto app_launch_info = restore_data().GetAppLaunchInfo(kAppId1, kWindowId1);
EXPECT_FALSE(app_launch_info);
// Add the app launch info.
AddAppLaunchInfos();
app_launch_info = restore_data().GetAppLaunchInfo(kAppId1, kWindowId1);
// Verify the app launch info.
EXPECT_TRUE(app_launch_info);
EXPECT_EQ(kAppId1, app_launch_info->app_id);
EXPECT_THAT(app_launch_info->window_id, testing::Optional(kWindowId1));
EXPECT_FALSE(app_launch_info->event_flag.has_value());
EXPECT_THAT(app_launch_info->container,
testing::Optional(static_cast<int>(
apps::LaunchContainer::kLaunchContainerWindow)));
EXPECT_THAT(
app_launch_info->disposition,
testing::Optional(static_cast<int>(WindowOpenDisposition::NEW_WINDOW)));
EXPECT_FALSE(app_launch_info->arc_session_id.has_value());
EXPECT_THAT(app_launch_info->display_id, testing::Optional(kDisplayId1));
const std::vector<base::FilePath> expected_file_paths = {
base::FilePath(kFilePath1), base::FilePath(kFilePath2)};
EXPECT_EQ(expected_file_paths, app_launch_info->file_paths);
EXPECT_TRUE(app_launch_info->intent);
EXPECT_EQ(kIntentActionSend, app_launch_info->intent->action);
EXPECT_EQ(kMimeType, app_launch_info->intent->mime_type);
EXPECT_EQ(kShareText1, app_launch_info->intent->share_text);
EXPECT_FALSE(
app_launch_info->browser_extra_info.app_type_browser.has_value());
}
TEST_F(RestoreDataTest, GetWindowInfo) {
// The app id and window id doesn't exist.
auto window_info = restore_data().GetWindowInfo(kAppId1, kWindowId1);
EXPECT_FALSE(window_info);
// Add the app launch info, but do not modify the window info.
AddAppLaunchInfos();
window_info = restore_data().GetWindowInfo(kAppId1, kWindowId1);
ASSERT_TRUE(window_info);
EXPECT_FALSE(window_info->activation_index.has_value());
EXPECT_FALSE(window_info->desk_id.has_value());
EXPECT_FALSE(window_info->desk_guid.is_valid());
EXPECT_FALSE(window_info->current_bounds.has_value());
EXPECT_FALSE(window_info->window_state_type.has_value());
// Modify the window info.
ModifyWindowInfos();
window_info = restore_data().GetWindowInfo(kAppId1, kWindowId1);
ASSERT_TRUE(window_info);
EXPECT_THAT(window_info->activation_index,
testing::Optional(kActivationIndex1));
EXPECT_THAT(window_info->desk_id, testing::Optional(kDeskId1));
EXPECT_TRUE(window_info->desk_guid.is_valid());
EXPECT_EQ(kDeskGuid1, window_info->desk_guid);
EXPECT_THAT(window_info->current_bounds, testing::Optional(kCurrentBounds1));
EXPECT_THAT(window_info->window_state_type,
testing::Optional(kWindowStateType1));
EXPECT_FALSE(window_info->display_id.has_value());
}
TEST_F(RestoreDataTest, GetAppWindowInfo) {
// Add the app launch info, but do not modify the window info.
AddAppLaunchInfos();
const auto it = restore_data().app_id_to_launch_list().find(kAppId2);
EXPECT_TRUE(it != restore_data().app_id_to_launch_list().end());
EXPECT_FALSE(it->second.empty());
auto data_it = it->second.find(kWindowId3);
EXPECT_TRUE(data_it != it->second.end());
auto app_window_info = data_it->second->GetAppWindowInfo();
ASSERT_TRUE(app_window_info);
EXPECT_EQ(0, app_window_info->state);
EXPECT_EQ(kDisplayId2, app_window_info->display_id);
EXPECT_FALSE(app_window_info->bounds);
// Modify the window info.
ModifyWindowInfos();
app_window_info = data_it->second->GetAppWindowInfo();
EXPECT_EQ(static_cast<int32_t>(kWindowStateType3), app_window_info->state);
EXPECT_EQ(kDisplayId1, app_window_info->display_id);
EXPECT_TRUE(app_window_info->bounds);
EXPECT_EQ(kCurrentBounds3, app_window_info->bounds.value());
}
TEST_F(RestoreDataTest, FetchRestoreWindowId) {
// Add the app launch info, but do not modify the window info.
AddAppLaunchInfos();
// Modify the window info.
ModifyWindowInfos();
restore_data().SetNextRestoreWindowIdForChromeApp(kAppId2);
EXPECT_EQ(kWindowId3, restore_data().FetchRestoreWindowId(kAppId2));
// Verify that the activation index is not modified.
auto window_info = restore_data().GetWindowInfo(kAppId2, kWindowId3);
ASSERT_TRUE(window_info);
EXPECT_THAT(window_info->activation_index,
testing::Optional(kActivationIndex3));
restore_data().SetNextRestoreWindowIdForChromeApp(kAppId1);
// Verify that the activation index is modified as INT32_MAX.
EXPECT_EQ(kWindowId1, restore_data().FetchRestoreWindowId(kAppId1));
window_info = restore_data().GetWindowInfo(kAppId1, kWindowId1);
ASSERT_TRUE(window_info);
EXPECT_THAT(window_info->activation_index, testing::Optional(INT32_MAX));
// Verify that the activation index is modified as INT32_MAX.
EXPECT_EQ(kWindowId2, restore_data().FetchRestoreWindowId(kAppId1));
window_info = restore_data().GetWindowInfo(kAppId1, kWindowId2);
ASSERT_TRUE(window_info);
EXPECT_THAT(window_info->activation_index, testing::Optional(INT32_MAX));
EXPECT_EQ(0, restore_data().FetchRestoreWindowId(kAppId1));
}
TEST_F(RestoreDataTest, HasAppTypeBrowser) {
auto app_launch_info1 =
std::make_unique<AppLaunchInfo>(app_constants::kChromeAppId, kWindowId1);
restore_data().AddAppLaunchInfo(std::move(app_launch_info1));
EXPECT_FALSE(restore_data().HasAppTypeBrowser());
auto app_launch_info2 =
std::make_unique<AppLaunchInfo>(app_constants::kChromeAppId, kWindowId2);
app_launch_info2->browser_extra_info.app_type_browser = true;
restore_data().AddAppLaunchInfo(std::move(app_launch_info2));
EXPECT_TRUE(restore_data().HasAppTypeBrowser());
}
TEST_F(RestoreDataTest, HasBrowser) {
auto app_launch_info1 =
std::make_unique<AppLaunchInfo>(app_constants::kChromeAppId, kWindowId1);
app_launch_info1->browser_extra_info.app_type_browser = true;
restore_data().AddAppLaunchInfo(std::move(app_launch_info1));
EXPECT_FALSE(restore_data().HasBrowser());
auto app_launch_info2 =
std::make_unique<AppLaunchInfo>(app_constants::kChromeAppId, kWindowId2);
restore_data().AddAppLaunchInfo(std::move(app_launch_info2));
EXPECT_TRUE(restore_data().HasBrowser());
}
TEST_F(RestoreDataTest, UpdateAppIdToLacros) {
auto app_launch_info1 =
std::make_unique<AppLaunchInfo>(app_constants::kChromeAppId, kWindowId1);
restore_data().AddAppLaunchInfo(std::move(app_launch_info1));
// Verify that ash chrome is added.
const auto ash_chrome_it =
restore_data().app_id_to_launch_list().find(app_constants::kChromeAppId);
EXPECT_TRUE(ash_chrome_it != restore_data().app_id_to_launch_list().end());
EXPECT_FALSE(ash_chrome_it->second.empty());
restore_data().UpdateBrowserAppIdToLacros();
// Verify that ash chrome app id is modified to lacros version.
const auto lacros_chrome_it =
restore_data().app_id_to_launch_list().find(app_constants::kLacrosAppId);
const auto ash_chrome_after_update_it =
restore_data().app_id_to_launch_list().find(app_constants::kChromeAppId);
EXPECT_TRUE(lacros_chrome_it != restore_data().app_id_to_launch_list().end());
EXPECT_FALSE(lacros_chrome_it->second.empty());
EXPECT_TRUE(ash_chrome_after_update_it ==
restore_data().app_id_to_launch_list().end());
EXPECT_EQ(1u, restore_data().app_id_to_launch_list().size());
}
TEST_F(RestoreDataTest, CompareAppRestoreData) {
auto app_launch_info_1 = std::make_unique<AppLaunchInfo>(
kAppId1, kWindowId1, apps::LaunchContainer::kLaunchContainerWindow,
WindowOpenDisposition::NEW_WINDOW, kDisplayId1,
std::vector<base::FilePath>{base::FilePath(kFilePath1),
base::FilePath(kFilePath2)},
MakeIntent(kIntentActionSend, kMimeType, kShareText1));
app_launch_info_1->browser_extra_info.app_type_browser = kAppTypeBrower2;
app_launch_info_1->browser_extra_info.first_non_pinned_tab_index =
kFirstNonPinnedTabIndex;
PopulateTestTabgroups(app_launch_info_1->browser_extra_info.tab_group_infos);
// Same as `app_launch_info_1`.
auto app_launch_info_2 = std::make_unique<AppLaunchInfo>(
kAppId1, kWindowId1, apps::LaunchContainer::kLaunchContainerWindow,
WindowOpenDisposition::NEW_WINDOW, kDisplayId1,
std::vector<base::FilePath>{base::FilePath(kFilePath1),
base::FilePath(kFilePath2)},
MakeIntent(kIntentActionSend, kMimeType, kShareText1));
app_launch_info_2->browser_extra_info.app_type_browser = kAppTypeBrower2;
app_launch_info_2->browser_extra_info.first_non_pinned_tab_index =
kFirstNonPinnedTabIndex;
PopulateTestTabgroups(app_launch_info_2->browser_extra_info.tab_group_infos);
auto app_launch_info_3 = std::make_unique<AppLaunchInfo>(
kAppId1, kWindowId2, apps::LaunchContainer::kLaunchContainerTab,
WindowOpenDisposition::NEW_FOREGROUND_TAB, kDisplayId2,
std::vector<base::FilePath>{base::FilePath(kFilePath2)},
MakeIntent(kIntentActionView, kMimeType, kShareText2));
auto app_restore_data_1 =
std::make_unique<AppRestoreData>(std::move(app_launch_info_1));
auto app_restore_data_2 =
std::make_unique<AppRestoreData>(std::move(app_launch_info_2));
auto app_restore_data_3 =
std::make_unique<AppRestoreData>(std::move(app_launch_info_3));
EXPECT_TRUE(*app_restore_data_1 == *app_restore_data_2);
EXPECT_TRUE(*app_restore_data_1 != *app_restore_data_3);
// Modify tab groups of app_restore_data_2.
app_restore_data_2->browser_extra_info.tab_group_infos.push_back(
MakeTestTabGroup(kTestTabGroupTitleThree, kTestTabGroupColorThree));
EXPECT_TRUE(*app_restore_data_1 != *app_restore_data_2);
}
TEST_F(RestoreDataTest, CompareAppRestoreDataIntent) {
// Intent is nullptr.
auto app_launch_info_1 = std::make_unique<AppLaunchInfo>(
kAppId1, kWindowId1, apps::LaunchContainer::kLaunchContainerWindow,
WindowOpenDisposition::NEW_WINDOW, kDisplayId1,
std::vector<base::FilePath>{base::FilePath(kFilePath1),
base::FilePath(kFilePath2)},
nullptr);
// Same as `app_launch_info_1`.
auto app_launch_info_2 = std::make_unique<AppLaunchInfo>(
kAppId1, kWindowId1, apps::LaunchContainer::kLaunchContainerWindow,
WindowOpenDisposition::NEW_WINDOW, kDisplayId1,
std::vector<base::FilePath>{base::FilePath(kFilePath1),
base::FilePath(kFilePath2)},
nullptr);
auto app_restore_data_1 =
std::make_unique<AppRestoreData>(std::move(app_launch_info_1));
auto app_restore_data_2 =
std::make_unique<AppRestoreData>(std::move(app_launch_info_2));
// Intent both nullptr.
EXPECT_TRUE(*app_restore_data_1 == *app_restore_data_2);
// Add intent to app_restore_data_1.
app_restore_data_1->intent =
MakeIntent(kIntentActionView, kMimeType, kShareText1);
EXPECT_TRUE(*app_restore_data_1 != *app_restore_data_2);
// Add intent to app_restore_data_2, different from app_restore_data_1.
app_restore_data_2->intent =
MakeIntent(kIntentActionView, kMimeType, kShareText2);
EXPECT_TRUE(*app_restore_data_1 != *app_restore_data_2);
// Modify app_restore_data_2 to the same as app_restore_data_1.
app_restore_data_2->intent =
MakeIntent(kIntentActionView, kMimeType, kShareText1);
EXPECT_TRUE(*app_restore_data_1 == *app_restore_data_2);
}
} // namespace app_restore
Codebase Browser
chromium