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
|
// 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.
#ifndef CONTENT_BROWSER_RENDERER_HOST_RECENTLY_DESTROYED_HOSTS_H_
#define CONTENT_BROWSER_RENDERER_HOST_RECENTLY_DESTROYED_HOSTS_H_
#include "base/containers/flat_set.h"
#include "base/supports_user_data.h"
#include "base/time/time.h"
#include "content/common/content_export.h"
namespace base {
class TimeDelta;
class TimeTicks;
} // namespace base
namespace content {
class BrowserContext;
class ProcessLock;
class RenderProcessHost;
// Stores information about recently destroyed RenderProcessHosts in order to
// determine how often a process is created for a site that a just-destroyed
// host could have hosted. Emits the "SiteIsolation.ReusePendingOrCommittedSite.
// TimeSinceReusableProcessDestroyed" metric, which tracks this.
//
// Experimentally used to delay subframe-process shutdown. This aims to reduce
// process churn by keeping subframe processes alive for a few seconds. See
// GetSubframeProcessShutdownDelay() for details.
class CONTENT_EXPORT RecentlyDestroyedHosts
: public base::SupportsUserData::Data {
public:
// Storage time for information about recently destroyed processes. Intended
// to be long enough to capture a large portion of the process-reuse
// opportunity.
static constexpr base::TimeDelta kRecentlyDestroyedStorageTimeout =
base::Seconds(15);
~RecentlyDestroyedHosts() override;
RecentlyDestroyedHosts(const RecentlyDestroyedHosts& other) = delete;
RecentlyDestroyedHosts& operator=(const RecentlyDestroyedHosts& other) =
delete;
// If a host matching |process_lock| was recently destroyed, records the
// interval between its destruction and |reusable_host_lookup_time|. If not,
// records a sentinel value.
static void RecordMetricIfReusableHostRecentlyDestroyed(
const base::TimeTicks& reusable_host_lookup_time,
const ProcessLock& process_lock,
BrowserContext* browser_context);
// Adds |host|'s process lock to the list of recently destroyed hosts, or
// updates its time if it's already present.
static void Add(RenderProcessHost* host,
const base::TimeDelta& time_spent_running_unload_handlers,
BrowserContext* browser_context);
private:
friend class RecentlyDestroyedHostsTest;
// The |interval| between a renderer process's destruction and the creation of
// another renderer process for the same domain.
struct ReuseInterval {
base::TimeDelta interval;
base::TimeTicks time_added;
bool operator<(const ReuseInterval& rhs) const {
return std::tie(interval, time_added) <
std::tie(rhs.interval, rhs.time_added);
}
};
RecentlyDestroyedHosts();
// Returns the RecentlyDestroyedHosts instance stored in |browser_context|, or
// creates an instance in |browser_context| and returns it if none exists.
static RecentlyDestroyedHosts* GetInstance(BrowserContext* browser_context);
// Removes all entries older than |kRecentlyDestroyedStorageTimeout| from
// |recently_destroyed_hosts_|.
void RemoveExpiredEntries();
void AddReuseInterval(const base::TimeDelta& interval);
// List of recent intervals between renderer-process destruction and the
// creation of a renderer process for the same site. Sorted by interval, from
// shortest to longest. Only a limited number are stored.
base::flat_set<ReuseInterval> reuse_intervals_;
// Map of ProcessLock to destruction time, for RenderProcessHosts destroyed
// in the last |kRecentlyDestroyedStorageTimeout| seconds.
std::map<ProcessLock, base::TimeTicks> recently_destroyed_hosts_;
};
} // namespace content
#endif // CONTENT_BROWSER_RENDERER_HOST_RECENTLY_DESTROYED_HOSTS_H_
|
