freezing.cc 13 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360
  1. // Copyright 2020 The Chromium Authors. All rights reserved.
  2. // Use of this source code is governed by a BSD-style license that can be
  3. // found in the LICENSE file.
  4. #include "components/performance_manager/public/freezing/freezing.h"
  5. #include <memory>
  6. #include "base/bind.h"
  7. #include "base/containers/contains.h"
  8. #include "base/containers/flat_map.h"
  9. #include "base/containers/flat_set.h"
  10. #include "base/memory/ptr_util.h"
  11. #include "base/memory/raw_ptr.h"
  12. #include "base/scoped_observation.h"
  13. #include "base/sequence_checker.h"
  14. #include "base/task/sequenced_task_runner.h"
  15. #include "base/thread_annotations.h"
  16. #include "components/performance_manager/freezing/freezing_vote_aggregator.h"
  17. #include "components/performance_manager/graph/graph_impl.h"
  18. #include "components/performance_manager/graph/node_attached_data_impl.h"
  19. #include "components/performance_manager/graph/page_node_impl.h"
  20. #include "components/performance_manager/performance_manager_impl.h"
  21. #include "components/performance_manager/public/graph/graph.h"
  22. #include "components/performance_manager/public/graph/graph_registered.h"
  23. #include "components/performance_manager/public/graph/page_node.h"
  24. #include "components/performance_manager/public/performance_manager.h"
  25. #include "content/public/browser/browser_thread.h"
  26. #include "content/public/browser/web_contents.h"
  27. namespace performance_manager {
  28. namespace freezing {
  29. namespace {
  30. class FreezingVoteTokenImpl;
  31. // NodeAttachedData used to store the set of FreezingVoteTokenImpl objects
  32. // associated with a PageNode.
  33. class FreezingVoteNodeData : public NodeAttachedDataImpl<FreezingVoteNodeData> {
  34. public:
  35. struct Traits : public NodeAttachedDataInMap<PageNodeImpl> {};
  36. ~FreezingVoteNodeData() override = default;
  37. void AddVote(FreezingVoteTokenImpl* token);
  38. void RemoveVote(FreezingVoteTokenImpl* token);
  39. bool IsEmpty() { return vote_tokens_.empty(); }
  40. const base::flat_set<FreezingVoteTokenImpl*>& vote_tokens() {
  41. return vote_tokens_;
  42. }
  43. private:
  44. friend class ::performance_manager::NodeAttachedDataImpl<
  45. FreezingVoteNodeData>;
  46. explicit FreezingVoteNodeData(const PageNodeImpl* page_node) {}
  47. // The freezing votes associated with this node.
  48. base::flat_set<FreezingVoteTokenImpl*> vote_tokens_;
  49. };
  50. // A registry of FreezingVoteToken that lives on the PM sequence.
  51. //
  52. // There can be multiple freezing votes associated with the same page node.
  53. class FreezingVoteTokenPMRegistry
  54. : public PageNode::ObserverDefaultImpl,
  55. public GraphOwned,
  56. public GraphRegisteredImpl<FreezingVoteTokenPMRegistry> {
  57. public:
  58. // A map that associates a voting token to a
  59. // <FreezingVotingChannel, const PageNode*> pair.
  60. using VotingChannelsMap =
  61. base::flat_map<FreezingVoteTokenImpl*,
  62. std::pair<FreezingVotingChannel, const PageNode*>>;
  63. // Returns the FreezingVoteTokenPMRegistry graph owned instance, creates it if
  64. // necessary. Can only be called from the PM sequence.
  65. static FreezingVoteTokenPMRegistry* GetOrCreateInstance(Graph* graph);
  66. FreezingVoteTokenPMRegistry(const FreezingVoteTokenPMRegistry& other) =
  67. delete;
  68. FreezingVoteTokenPMRegistry& operator=(const FreezingVoteTokenPMRegistry&) =
  69. delete;
  70. // Register a freezing vote for |contents|. |token| is an ID to associate with
  71. // this vote, there can be only one vote associated with this ID and it as to
  72. // be passed |UnregisterVote| when the vote is invalidated. This can only be
  73. // called from the UI thread.
  74. static void RegisterVoteForWebContents(content::WebContents* contents,
  75. FreezingVoteValue vote_value,
  76. const char* vote_reason,
  77. FreezingVoteTokenImpl* token);
  78. // Unregister the vote associated with |token|. This can only be called from
  79. // the UI thread.
  80. static void UnregisterVote(FreezingVoteTokenImpl* token);
  81. const VotingChannelsMap& voting_channels_for_testing() {
  82. return voting_channels_;
  83. }
  84. private:
  85. FreezingVoteTokenPMRegistry() = default;
  86. // Register a vote for |page_node| on the PM sequence. |token| is an ID
  87. // associated with this vote that will be used when invalidating it.
  88. void RegisterVoteOnPMSequence(base::WeakPtr<PageNode> page_node,
  89. FreezingVote vote,
  90. FreezingVoteTokenImpl* token);
  91. // Unregister the vote associated with |token|.
  92. void UnregisterVoteOnPMSequence(FreezingVoteTokenImpl* token);
  93. // PageNodeObserver:
  94. void OnBeforePageNodeRemoved(const PageNode* page_node) override;
  95. // GraphOwned:
  96. void OnPassedToGraph(Graph* graph) override;
  97. void OnTakenFromGraph(Graph* graph) override;
  98. // Reset the voting channel associated with |voting_channel_iter| and remove
  99. // this entry from |voting_channels_|. |voting_channel_iter| has to be a valid
  100. // iterator from |voting_channels_|
  101. void ResetAndRemoveVotingChannel(
  102. VotingChannelsMap::iterator& voting_channel_iter,
  103. const PageNode* page_node);
  104. VotingChannelsMap voting_channels_ GUARDED_BY_CONTEXT(sequence_checker_);
  105. raw_ptr<Graph> graph_ GUARDED_BY_CONTEXT(sequence_checker_);
  106. SEQUENCE_CHECKER(sequence_checker_);
  107. };
  108. // Concrete implementation of a FreezingVoteToken.
  109. class FreezingVoteTokenImpl : public FreezingVoteToken {
  110. public:
  111. FreezingVoteTokenImpl(content::WebContents* contents,
  112. FreezingVoteValue vote_value,
  113. const char* vote_reason);
  114. ~FreezingVoteTokenImpl() override;
  115. FreezingVoteTokenImpl(const FreezingVoteTokenImpl& other) = delete;
  116. FreezingVoteTokenImpl& operator=(const FreezingVoteTokenImpl&) = delete;
  117. };
  118. } // namespace
  119. FreezingVoteToken::FreezingVoteToken() = default;
  120. FreezingVoteToken::~FreezingVoteToken() = default;
  121. void FreezingVoteNodeData::AddVote(FreezingVoteTokenImpl* token) {
  122. DCHECK(!base::Contains(vote_tokens_, token));
  123. vote_tokens_.insert(token);
  124. }
  125. void FreezingVoteNodeData::RemoveVote(FreezingVoteTokenImpl* token) {
  126. DCHECK(base::Contains(vote_tokens_, token));
  127. vote_tokens_.erase(token);
  128. }
  129. // static
  130. FreezingVoteTokenPMRegistry* FreezingVoteTokenPMRegistry::GetOrCreateInstance(
  131. Graph* graph) {
  132. DCHECK(PerformanceManager::GetTaskRunner()->RunsTasksInCurrentSequence());
  133. auto* instance = graph->GetRegisteredObjectAs<FreezingVoteTokenPMRegistry>();
  134. if (!instance) {
  135. auto registry = base::WrapUnique(new FreezingVoteTokenPMRegistry());
  136. instance = registry.get();
  137. graph->PassToGraph(std::move(registry));
  138. }
  139. return instance;
  140. }
  141. // static
  142. void FreezingVoteTokenPMRegistry::RegisterVoteForWebContents(
  143. content::WebContents* contents,
  144. FreezingVoteValue vote_value,
  145. const char* vote_reason,
  146. FreezingVoteTokenImpl* token) {
  147. DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
  148. // Register the vote on the PM sequence.
  149. PerformanceManager::CallOnGraph(
  150. FROM_HERE,
  151. base::BindOnce(
  152. [](base::WeakPtr<PageNode> page_node, FreezingVote vote,
  153. FreezingVoteTokenImpl* token, Graph* graph) {
  154. auto* registry =
  155. FreezingVoteTokenPMRegistry::GetOrCreateInstance(graph);
  156. registry->RegisterVoteOnPMSequence(page_node, vote, token);
  157. },
  158. PerformanceManager::GetPrimaryPageNodeForWebContents(contents),
  159. FreezingVote(vote_value, vote_reason), token));
  160. }
  161. // static
  162. void FreezingVoteTokenPMRegistry::UnregisterVote(FreezingVoteTokenImpl* token) {
  163. DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
  164. // Unregister the vote on the PM sequence.
  165. PerformanceManager::CallOnGraph(
  166. FROM_HERE,
  167. base::BindOnce(
  168. [](FreezingVoteTokenImpl* token, Graph* graph) {
  169. auto* registry =
  170. FreezingVoteTokenPMRegistry::GetOrCreateInstance(graph);
  171. registry->UnregisterVoteOnPMSequence(token);
  172. },
  173. token));
  174. }
  175. void FreezingVoteTokenPMRegistry::RegisterVoteOnPMSequence(
  176. base::WeakPtr<PageNode> page_node,
  177. FreezingVote vote,
  178. FreezingVoteTokenImpl* token) {
  179. DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
  180. DCHECK(page_node);
  181. DCHECK(!base::Contains(voting_channels_, token));
  182. auto* node_data = FreezingVoteNodeData::GetOrCreate(
  183. PageNodeImpl::FromNode(page_node.get()));
  184. auto voting_channel = graph_->GetRegisteredObjectAs<FreezingVoteAggregator>()
  185. ->GetVotingChannel();
  186. voting_channel.SubmitVote(page_node.get(), vote);
  187. voting_channels_[token] =
  188. std::make_pair(std::move(voting_channel), page_node.get());
  189. node_data->AddVote(token);
  190. }
  191. void FreezingVoteTokenPMRegistry::UnregisterVoteOnPMSequence(
  192. FreezingVoteTokenImpl* token) {
  193. DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
  194. auto voting_channel = voting_channels_.find(token);
  195. // The vote might be missing from |voting_channels_| if this gets called
  196. // after the corresponding PageNode has been destroyed.
  197. if (voting_channel == voting_channels_.end()) {
  198. return;
  199. }
  200. auto* page_node = voting_channel->second.second;
  201. ResetAndRemoveVotingChannel(voting_channel, page_node);
  202. auto* node_data =
  203. FreezingVoteNodeData::Get(PageNodeImpl::FromNode(page_node));
  204. DCHECK(node_data);
  205. node_data->RemoveVote(token);
  206. // Removes the node attached data if there's no more vote associated with this
  207. // node.
  208. if (node_data->IsEmpty())
  209. FreezingVoteNodeData::Destroy(PageNodeImpl::FromNode(page_node));
  210. }
  211. void FreezingVoteTokenPMRegistry::OnBeforePageNodeRemoved(
  212. const PageNode* page_node) {
  213. DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
  214. auto* node_data =
  215. FreezingVoteNodeData::Get(PageNodeImpl::FromNode(page_node));
  216. if (!node_data)
  217. return;
  218. // Invalidate the votes if its associated page node is destroyed. This can
  219. // happen if a freezing vote token is released after the destruction of the
  220. // WebContents it's associated with.
  221. for (const auto* token_iter : node_data->vote_tokens()) {
  222. auto voting_channel = voting_channels_.find(token_iter);
  223. DCHECK(voting_channel != voting_channels_.end());
  224. ResetAndRemoveVotingChannel(voting_channel, page_node);
  225. }
  226. }
  227. void FreezingVoteTokenPMRegistry::OnPassedToGraph(Graph* graph) {
  228. DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
  229. graph->RegisterObject(this);
  230. graph->AddPageNodeObserver(this);
  231. graph_ = graph;
  232. }
  233. void FreezingVoteTokenPMRegistry::OnTakenFromGraph(Graph* graph) {
  234. DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
  235. graph->UnregisterObject(this);
  236. graph->RemovePageNodeObserver(this);
  237. graph_ = nullptr;
  238. }
  239. void FreezingVoteTokenPMRegistry::ResetAndRemoveVotingChannel(
  240. VotingChannelsMap::iterator& voting_channel_iter,
  241. const PageNode* page_node) {
  242. DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
  243. voting_channel_iter->second.first.InvalidateVote(page_node);
  244. voting_channel_iter->second.first.Reset();
  245. voting_channels_.erase(voting_channel_iter);
  246. }
  247. FreezingVoteTokenImpl::FreezingVoteTokenImpl(content::WebContents* contents,
  248. FreezingVoteValue vote_value,
  249. const char* vote_reason) {
  250. FreezingVoteTokenPMRegistry::RegisterVoteForWebContents(contents, vote_value,
  251. vote_reason, this);
  252. }
  253. FreezingVoteTokenImpl::~FreezingVoteTokenImpl() {
  254. FreezingVoteTokenPMRegistry::UnregisterVote(this);
  255. }
  256. std::unique_ptr<FreezingVoteToken> EmitFreezingVoteForWebContents(
  257. content::WebContents* contents,
  258. FreezingVoteValue vote_value,
  259. const char* vote_reason) {
  260. DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
  261. return std::make_unique<FreezingVoteTokenImpl>(contents, vote_value,
  262. vote_reason);
  263. }
  264. const char* FreezingVoteValueToString(FreezingVoteValue freezing_vote_value) {
  265. if (freezing_vote_value == freezing::FreezingVoteValue::kCanFreeze) {
  266. return "kCanFreeze";
  267. } else {
  268. return "kCannotFreeze";
  269. }
  270. }
  271. size_t FreezingVoteCountForPageOnPMForTesting(PageNode* page_node) {
  272. DCHECK(PerformanceManager::GetTaskRunner()->RunsTasksInCurrentSequence());
  273. auto* node_data =
  274. FreezingVoteNodeData::Get(PageNodeImpl::FromNode(page_node));
  275. if (!node_data)
  276. return 0;
  277. return node_data->vote_tokens().size();
  278. }
  279. size_t TotalFreezingVoteCountOnPMForTesting(Graph* graph) {
  280. DCHECK(PerformanceManager::GetTaskRunner()->RunsTasksInCurrentSequence());
  281. auto* registry = FreezingVoteTokenPMRegistry::GetOrCreateInstance(graph);
  282. size_t registry_size = registry->voting_channels_for_testing().size();
  283. size_t page_nodes_vote_count = 0U;
  284. for (const PageNode* page_node : graph->GetAllPageNodes()) {
  285. auto* node_data =
  286. FreezingVoteNodeData::Get(PageNodeImpl::FromNode(page_node));
  287. if (node_data)
  288. page_nodes_vote_count += node_data->vote_tokens().size();
  289. }
  290. DCHECK_EQ(registry_size, page_nodes_vote_count);
  291. return registry_size;
  292. }
  293. } // namespace freezing
  294. } // namespace performance_manager