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
|
// Copyright 2019 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/performance_manager/graph/policies/process_priority_policy.h"
#include "components/performance_manager/public/render_process_host_proxy.h"
#include "content/public/browser/browser_thread.h"
#include "content/public/browser/render_process_host.h"
namespace performance_manager {
namespace policies {
namespace {
#if DCHECK_IS_ON()
size_t g_instance_count = 0;
#endif
// Used as a testing seam. If this is set then SetProcessPriorityOnUiThread will
// invoke the provided callback immediately after calling SetPriorityOverride on
// the RenderProcessHost.
ProcessPriorityPolicy::SetPriorityOnUiThreadCallback* g_callback = nullptr;
base::Process::Priority ToProcessPriority(base::TaskPriority priority) {
switch (priority) {
case base::TaskPriority::BEST_EFFORT:
return base::Process::Priority::kBestEffort;
case base::TaskPriority::USER_VISIBLE:
return base::Process::Priority::kUserVisible;
case base::TaskPriority::USER_BLOCKING:
return base::Process::Priority::kUserBlocking;
}
}
// Dispatches a process priority change to the RenderProcessHost associated with
// a given ProcessNode.
void SetProcessPriority(const ProcessNode* process_node,
base::Process::Priority priority) {
DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
if (process_node->GetProcessType() != content::PROCESS_TYPE_RENDERER) {
// This is triggered from ProcessNode observers that fire for all process
// types, but only renderer processes have a RenderProcessHostProxy.
return;
}
RenderProcessHostProxy rph_proxy = process_node->GetRenderProcessHostProxy();
CHECK(rph_proxy.Get());
rph_proxy.Get()->SetPriorityOverride(priority);
// Invoke the testing seam callback if one was provided.
if (g_callback && !g_callback->is_null()) {
g_callback->Run(rph_proxy, priority);
}
}
} // namespace
ProcessPriorityPolicy::ProcessPriorityPolicy() {
#if DCHECK_IS_ON()
DCHECK_EQ(0u, g_instance_count);
++g_instance_count;
#endif
}
ProcessPriorityPolicy::~ProcessPriorityPolicy() {
#if DCHECK_IS_ON()
DCHECK_EQ(1u, g_instance_count);
--g_instance_count;
#endif
}
// static
void ProcessPriorityPolicy::SetCallbackForTesting(
SetPriorityOnUiThreadCallback callback) {
ClearCallbackForTesting();
g_callback = new SetPriorityOnUiThreadCallback(callback);
}
void ProcessPriorityPolicy::ClearCallbackForTesting() {
if (!g_callback)
return;
delete g_callback;
g_callback = nullptr;
}
void ProcessPriorityPolicy::OnPassedToGraph(Graph* graph) {
DCHECK(graph->HasOnlySystemNode());
graph->AddProcessNodeObserver(this);
}
void ProcessPriorityPolicy::OnTakenFromGraph(Graph* graph) {
graph->RemoveProcessNodeObserver(this);
}
void ProcessPriorityPolicy::OnProcessNodeAdded(
const ProcessNode* process_node) {
CHECK_NE(process_node->GetPriority(), base::TaskPriority::USER_VISIBLE);
// Set the initial process priority.
// TODO(chrisha): Get provisional nodes working so we can make an informed
// choice in the graph (processes launching ads-to-be, or extensions, or
// frames for backgrounded tabs, etc, can be launched with background
// priority).
// TODO(chrisha): Make process creation take a detour through the graph in
// order to get the initial priority parameter that is set here. Currently
// this is effectively a nop.
SetProcessPriority(process_node,
ToProcessPriority(process_node->GetPriority()));
}
void ProcessPriorityPolicy::OnPriorityChanged(
const ProcessNode* process_node,
base::TaskPriority previous_value) {
base::Process::Priority previous_priority = ToProcessPriority(previous_value);
base::Process::Priority current_priority =
ToProcessPriority(process_node->GetPriority());
// Only set if the resulting process priority has changed.
if (previous_priority != current_priority) {
SetProcessPriority(process_node, current_priority);
}
}
} // namespace policies
} // namespace performance_manager
|
