1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
|
// Copyright 2015 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "chrome/browser/sessions/session_restore_delegate.h"
#include <stddef.h>
#include <array>
#include <utility>
#include "base/strings/string_util.h"
#include "base/metrics/field_trial.h"
#include "base/compiler_specific.h"
#include "base/metrics/field_trial.h"
#include "chrome/browser/performance_manager/public/background_tab_loading_policy.h"
#include "chrome/browser/sessions/session_restore_stats_collector.h"
#include "chrome/browser/sessions/tab_loader.h"
#include "chrome/common/url_constants.h"
#include "components/favicon/content/content_favicon_driver.h"
#include "components/performance_manager/public/features.h"
#include "components/tab_groups/tab_group_id.h"
#include "components/tab_groups/tab_group_visual_data.h"
#include "content/public/browser/web_contents.h"
namespace {
bool IsInternalPage(const GURL& url) {
// There are many chrome:// UI URLs, but only look for the ones that users
// are likely to have open. Most of the benefit is from the NTP URL.
const auto kReloadableUrlPrefixes = std::to_array<const char*>({
chrome::kChromeUIDownloadsURL,
chrome::kChromeUIHistoryURL,
chrome::kChromeUINewTabURL,
chrome::kChromeUISettingsURL,
});
// Prefix-match against the table above.
for (const char* prefix : kReloadableUrlPrefixes) {
if (base::StartsWith(url.spec(), prefix)) {
return true;
}
}
return false;
}
} // namespace
SessionRestoreDelegate::RestoredTab::RestoredTab(
content::WebContents* contents,
bool is_active,
bool is_app,
bool is_pinned,
const std::optional<tab_groups::TabGroupId>& group,
const std::optional<split_tabs::SplitTabId>& split)
: contents_(contents->GetWeakPtr()),
is_active_(is_active),
is_app_(is_app),
is_internal_page_(IsInternalPage(contents->GetLastCommittedURL())),
is_pinned_(is_pinned),
group_(group),
split_(split) {}
SessionRestoreDelegate::RestoredTab::RestoredTab(const RestoredTab&) = default;
SessionRestoreDelegate::RestoredTab&
SessionRestoreDelegate::RestoredTab::operator=(const RestoredTab&) = default;
SessionRestoreDelegate::RestoredTab::~RestoredTab() = default;
bool SessionRestoreDelegate::RestoredTab::operator<(
const RestoredTab& right) const {
// Tab with internal web UI like NTP or Settings are good choices to
// defer loading.
if (is_internal_page_ != right.is_internal_page_)
return !is_internal_page_;
// Pinned tabs should be loaded first.
if (is_pinned_ != right.is_pinned_)
return is_pinned_;
// Apps should be loaded before normal tabs.
if (is_app_ != right.is_app_)
return is_app_;
// Finally, older tabs should be deferred first.
return contents_->GetLastActiveTimeTicks() >
right.contents_->GetLastActiveTimeTicks();
}
// static
void SessionRestoreDelegate::RestoreTabs(
const std::vector<RestoredTab>& tabs,
const base::TimeTicks& restore_started) {
if (tabs.empty())
return;
// Restore the favicon for all tabs. Any tab may end up being deferred due
// to memory pressure so it's best to have some visual indication of its
// contents.
for (const auto& restored_tab : tabs) {
CHECK(restored_tab.contents());
// Restore the favicon for deferred tabs.
favicon::ContentFaviconDriver* favicon_driver =
favicon::ContentFaviconDriver::FromWebContents(restored_tab.contents());
if (favicon_driver) {
favicon_driver->FetchFavicon(favicon_driver->GetActiveURL(),
/*is_same_document=*/false);
}
}
SessionRestoreStatsCollector::GetOrCreateInstance(
restore_started,
std::make_unique<
SessionRestoreStatsCollector::UmaStatsReportingDelegate>())
->TrackTabs(tabs);
// Don't start a TabLoader here if background tab loading is done by
// PerformanceManager.
if (!base::FeatureList::IsEnabled(
performance_manager::features::
kBackgroundTabLoadingFromPerformanceManager)) {
TabLoader::RestoreTabs(tabs, restore_started);
} else {
std::vector<content::WebContents*> web_contents_vector;
web_contents_vector.reserve(tabs.size());
for (const auto& tab : tabs) {
CHECK(tab.contents());
web_contents_vector.push_back(tab.contents());
}
performance_manager::policies::ScheduleLoadForRestoredTabs(
std::move(web_contents_vector));
}
}
|
