[PM] Don't freeze unloaded tabs

The PerformanceManager page freezing policy doesn't take into account
the loading state of a tab when emitting freezing signals. As a result
some unloaded tabs can receive a freezing signal and there won't be
another freezing attempt once the tab gets loaded.

This fix this problem by waiting for the tab to transition to the
loaded state before emitting the freezing signal.

Bug: 1168735
Change-Id: I13b92600a2df7fa8bfc592a2711cb33b0631e409
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2641154Reviewed-by: Joe Mason <joenotcharles@chromium.org>
Commit-Queue: Sébastien Marchand <sebmarchand@chromium.org>
Cr-Commit-Position: refs/heads/master@{#845415}

chrome/browser/performance_manager/policies/page_freezing_policy.cc

@@ -101,12 +101,27 @@ void PageFreezingPolicy::OnFreezingVoteChanged(
     }
   } else {
     DCHECK_EQ(freezing::FreezingVoteValue::kCanFreeze, freezing_vote->value());
+
+    // Don't attempt to freeze a page if it's not fully loaded yet.
+    if (page_node->GetLoadingState() != PageNode::LoadingState::kLoadedIdle)
+      return;
+
     if (!IsPageNodeFrozen(page_node)) {
       page_freezer_->MaybeFreezePageNode(page_node);
     }
   }
 }
 
+void PageFreezingPolicy::OnLoadingStateChanged(const PageNode* page_node) {
+  if (page_node->GetLoadingState() != PageNode::LoadingState::kLoadedIdle)
+    return;
+  auto freezing_vote = page_node->GetFreezingVote();
+  if (freezing_vote.has_value() &&
+      freezing_vote->value() == freezing::FreezingVoteValue::kCanFreeze) {
+    page_freezer_->MaybeFreezePageNode(page_node);
+  }
+}
+
 void PageFreezingPolicy::OnIsConnectedToUSBDeviceChanged(
     const PageNode* page_node) {
   UpdateNegativeFreezingVote(

chrome/browser/performance_manager/policies/page_freezing_policy.h

@@ -98,6 +98,7 @@ class PageFreezingPolicy : public GraphOwned,
       const PageNode* page_node,
       base::Optional<performance_manager::freezing::FreezingVote> previous_vote)
       override;
+  void OnLoadingStateChanged(const PageNode* page_node) override;
 
   // PageLiveStateObserver:
   void OnIsConnectedToUSBDeviceChanged(const PageNode* page_node) override;

chrome/browser/performance_manager/policies/page_freezing_policy_unittest.cc

@@ -196,6 +196,7 @@ TEST_F(PageFreezingPolicyTest, FreezingVotes) {
       std::make_unique<MockPageFreezer>();
   auto* page_freezer_raw = page_freezer.get();
   policy()->SetPageFreezerForTesting(std::move(page_freezer));
+  page_node()->SetLoadingState(PageNode::LoadingState::kLoadedIdle);
 
   EXPECT_CALL(*page_freezer_raw, MaybeFreezePageNodeImpl(page_node()));
   page_node()->set_freezing_vote(kCanFreezeVote);
@@ -223,5 +224,25 @@ TEST_F(PageFreezingPolicyTest, FreezingVotes) {
   ::testing::Mock::VerifyAndClearExpectations(page_freezer_raw);
 }
 
+TEST_F(PageFreezingPolicyTest, PageNodeIsntFrozenBeforeLoadingCompletes) {
+  std::unique_ptr<MockPageFreezer> page_freezer =
+      std::make_unique<MockPageFreezer>();
+  auto* page_freezer_raw = page_freezer.get();
+  policy()->SetPageFreezerForTesting(std::move(page_freezer));
+  page_node()->SetLoadingState(PageNode::LoadingState::kLoadedBusy);
+  page_node()->set_freezing_vote(kCanFreezeVote);
+  // The page freezer shouldn't be called as the page node isn't fully loaded
+  // yet.
+  ::testing::Mock::VerifyAndClearExpectations(page_freezer_raw);
+  EXPECT_EQ(page_node()->freezing_vote()->value(),
+            freezing::FreezingVoteValue::kCanFreeze);
+
+  EXPECT_CALL(*page_freezer_raw, MaybeFreezePageNodeImpl(page_node()));
+  // A transition to the fully loaded state should cause the page node to be
+  // frozen.
+  page_node()->SetLoadingState(PageNode::LoadingState::kLoadedIdle);
+  ::testing::Mock::VerifyAndClearExpectations(page_freezer_raw);
+}
+
 }  // namespace policies
 }  // namespace performance_manager