Rename FreezeOriginTrialPolicyAggregator to PageAggregator

In a following CL I'll also add the necessary code to aggregate the use
of WebLocks and IndexedDB locks within a frame and I'll update the
corresponding page properties.

Bug: 980533
Change-Id: Ia22686215963415f586b3bcf20c363f305aaf591
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1832318
Commit-Queue: Sébastien Marchand <sebmarchand@chromium.org>
Reviewed-by: François Doray <fdoray@chromium.org>
Cr-Commit-Position: refs/heads/master@{#702134}

chrome/browser/BUILD.gn

@@ -1076,10 +1076,10 @@ jumbo_split_static_library("browser") {
     "performance_manager/chrome_browser_main_extra_parts_performance_manager.h",
     "performance_manager/chrome_content_browser_client_performance_manager_part.cc",
     "performance_manager/chrome_content_browser_client_performance_manager_part.h",
-    "performance_manager/decorators/freeze_origin_trial_policy_aggregator.cc",
-    "performance_manager/decorators/freeze_origin_trial_policy_aggregator.h",
     "performance_manager/decorators/frozen_frame_aggregator.cc",
     "performance_manager/decorators/frozen_frame_aggregator.h",
+    "performance_manager/decorators/page_aggregator.cc",
+    "performance_manager/decorators/page_aggregator.h",
     "performance_manager/decorators/page_almost_idle_decorator.cc",
     "performance_manager/decorators/page_almost_idle_decorator.h",
     "performance_manager/decorators/process_metrics_decorator.cc",

chrome/browser/performance_manager/chrome_browser_main_extra_parts_performance_manager.cc

@@ -10,8 +10,8 @@
 #include "base/feature_list.h"
 #include "build/build_config.h"
 #include "chrome/browser/performance_manager/browser_child_process_watcher.h"
-#include "chrome/browser/performance_manager/decorators/freeze_origin_trial_policy_aggregator.h"
 #include "chrome/browser/performance_manager/decorators/frozen_frame_aggregator.h"
+#include "chrome/browser/performance_manager/decorators/page_aggregator.h"
 #include "chrome/browser/performance_manager/decorators/page_almost_idle_decorator.h"
 #include "chrome/browser/performance_manager/decorators/process_metrics_decorator.h"
 #include "chrome/browser/performance_manager/graph/graph_impl.h"
@@ -69,8 +69,7 @@ void ChromeBrowserMainExtraPartsPerformanceManager::PostMainMessageLoopRun() {
 // static
 void ChromeBrowserMainExtraPartsPerformanceManager::
     CreateDefaultPoliciesAndDecorators(performance_manager::GraphImpl* graph) {
-  graph->PassToGraph(std::make_unique<
-                     performance_manager::FreezeOriginTrialPolicyAggregator>());
+  graph->PassToGraph(std::make_unique<performance_manager::PageAggregator>());
   graph->PassToGraph(
       std::make_unique<performance_manager::FrozenFrameAggregator>());
   graph->PassToGraph(

chrome/browser/performance_manager/decorators/freeze_origin_trial_policy_aggregator.cc → chrome/browser/performance_manager/decorators/page_aggregator.cc

@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "chrome/browser/performance_manager/decorators/freeze_origin_trial_policy_aggregator.h"
+#include "chrome/browser/performance_manager/decorators/page_aggregator.h"
 
 #include <stdint.h>
 
@@ -14,14 +14,14 @@ namespace performance_manager {
 
 using resource_coordinator::mojom::InterventionPolicy;
 
-// Provides FreezeOriginTrialPolicyAggregator machinery access to some internals
+// Provides PageAggregator machinery access to some internals
 // of a PageNodeImpl.
-class FreezeOriginTrialPolicyAggregatorAccess {
+class PageAggregatorAccess {
  public:
-  using StorageType = decltype(PageNodeImpl::freeze_origin_trial_policy_data_);
+  using StorageType = decltype(PageNodeImpl::page_aggregator_data_);
 
   static StorageType* GetInternalStorage(PageNodeImpl* page_node) {
-    return &page_node->freeze_origin_trial_policy_data_;
+    return &page_node->page_aggregator_data_;
   }
 
   static void SetOriginTrialFreezePolicy(PageNodeImpl* page_node,
@@ -30,45 +30,45 @@ class FreezeOriginTrialPolicyAggregatorAccess {
   }
 };
 
-class FreezeOriginTrialPolicyAggregator::Data
-    : public NodeAttachedDataImpl<Data> {
+class PageAggregator::Data : public NodeAttachedDataImpl<Data> {
  public:
-  using StorageType = FreezeOriginTrialPolicyAggregatorAccess::StorageType;
+  using StorageType = PageAggregatorAccess::StorageType;
   struct Traits : public NodeAttachedDataInternalOnNodeType<PageNodeImpl> {};
 
   explicit Data(const PageNodeImpl* page_node) {}
   ~Data() override = default;
 
   static StorageType* GetInternalStorage(PageNodeImpl* page_node) {
-    return FreezeOriginTrialPolicyAggregatorAccess::GetInternalStorage(
-        page_node);
+    return PageAggregatorAccess::GetInternalStorage(page_node);
   }
 
-  void IncrementFrameCountForPolicy(InterventionPolicy policy) {
-    ++num_current_frames_for_policy[static_cast<size_t>(policy)];
+  void IncrementFrameCountForFreezingPolicy(InterventionPolicy policy) {
+    ++num_current_frames_for_freezing_policy[static_cast<size_t>(policy)];
   }
 
-  void DecrementFrameCountForPolicy(InterventionPolicy policy) {
-    DCHECK_GT(num_current_frames_for_policy[static_cast<size_t>(policy)], 0U);
-    --num_current_frames_for_policy[static_cast<size_t>(policy)];
+  void DecrementFrameCountForFreezingPolicy(InterventionPolicy policy) {
+    DCHECK_GT(
+        num_current_frames_for_freezing_policy[static_cast<size_t>(policy)],
+        0U);
+    --num_current_frames_for_freezing_policy[static_cast<size_t>(policy)];
   }
 
   // Updates the page's origin trial freeze policy from current data.
   void UpdateOriginTrialFreezePolicy(PageNodeImpl* page_node) {
-    FreezeOriginTrialPolicyAggregatorAccess::SetOriginTrialFreezePolicy(
+    PageAggregatorAccess::SetOriginTrialFreezePolicy(
         page_node, ComputeOriginTrialFreezePolicy());
   }
 
  private:
   // Computes the page's origin trial freeze policy from current data.
   InterventionPolicy ComputeOriginTrialFreezePolicy() const {
-    if (GetNumCurrentFramesForPolicy(InterventionPolicy::kUnknown))
+    if (GetNumCurrentFramesForFreezingPolicy(InterventionPolicy::kUnknown))
       return InterventionPolicy::kUnknown;
 
-    if (GetNumCurrentFramesForPolicy(InterventionPolicy::kOptOut))
+    if (GetNumCurrentFramesForFreezingPolicy(InterventionPolicy::kOptOut))
       return InterventionPolicy::kOptOut;
 
-    if (GetNumCurrentFramesForPolicy(InterventionPolicy::kOptIn))
+    if (GetNumCurrentFramesForFreezingPolicy(InterventionPolicy::kOptIn))
       return InterventionPolicy::kOptIn;
 
     // A page with no frame can be frozen. This will have no effect.
@@ -77,57 +77,52 @@ class FreezeOriginTrialPolicyAggregator::Data
 
   // Returns the number of current frames with |policy| on the page that owns
   // this Data.
-  uint32_t GetNumCurrentFramesForPolicy(InterventionPolicy policy) const {
-    return num_current_frames_for_policy[static_cast<size_t>(policy)];
+  uint32_t GetNumCurrentFramesForFreezingPolicy(
+      InterventionPolicy policy) const {
+    return num_current_frames_for_freezing_policy[static_cast<size_t>(policy)];
   }
 
   // The number of current frames of this page that has set each freeze origin
   // trial policy.
-  uint32_t num_current_frames_for_policy[static_cast<size_t>(
-                                             InterventionPolicy::kMaxValue) +
-                                         1] = {};
+  uint32_t num_current_frames_for_freezing_policy
+      [static_cast<size_t>(InterventionPolicy::kMaxValue) + 1] = {};
 
   DISALLOW_COPY_AND_ASSIGN(Data);
 };
 
-FreezeOriginTrialPolicyAggregator::FreezeOriginTrialPolicyAggregator() =
-    default;
-FreezeOriginTrialPolicyAggregator::~FreezeOriginTrialPolicyAggregator() =
-    default;
+PageAggregator::PageAggregator() = default;
+PageAggregator::~PageAggregator() = default;
 
-void FreezeOriginTrialPolicyAggregator::OnFrameNodeAdded(
-    const FrameNode* frame_node) {
+void PageAggregator::OnFrameNodeAdded(const FrameNode* frame_node) {
   DCHECK(!frame_node->IsCurrent());
 }
 
-void FreezeOriginTrialPolicyAggregator::OnBeforeFrameNodeRemoved(
-    const FrameNode* frame_node) {
+void PageAggregator::OnBeforeFrameNodeRemoved(const FrameNode* frame_node) {
   if (frame_node->IsCurrent()) {
     auto* page_node = PageNodeImpl::FromNode(frame_node->GetPageNode());
     Data* data = Data::Get(page_node);
     // Data should have been created when the frame became current.
     DCHECK(data);
-    data->DecrementFrameCountForPolicy(
+    data->DecrementFrameCountForFreezingPolicy(
         frame_node->GetOriginTrialFreezePolicy());
     data->UpdateOriginTrialFreezePolicy(page_node);
   }
 }
 
-void FreezeOriginTrialPolicyAggregator::OnIsCurrentChanged(
-    const FrameNode* frame_node) {
+void PageAggregator::OnIsCurrentChanged(const FrameNode* frame_node) {
   auto* page_node = PageNodeImpl::FromNode(frame_node->GetPageNode());
   Data* data = Data::GetOrCreate(page_node);
   if (frame_node->IsCurrent()) {
-    data->IncrementFrameCountForPolicy(
+    data->IncrementFrameCountForFreezingPolicy(
         frame_node->GetOriginTrialFreezePolicy());
   } else {
-    data->DecrementFrameCountForPolicy(
+    data->DecrementFrameCountForFreezingPolicy(
         frame_node->GetOriginTrialFreezePolicy());
   }
   data->UpdateOriginTrialFreezePolicy(page_node);
 }
 
-void FreezeOriginTrialPolicyAggregator::OnOriginTrialFreezePolicyChanged(
+void PageAggregator::OnOriginTrialFreezePolicyChanged(
     const FrameNode* frame_node,
     const InterventionPolicy& previous_value) {
   if (frame_node->IsCurrent()) {
@@ -135,21 +130,21 @@ void FreezeOriginTrialPolicyAggregator::OnOriginTrialFreezePolicyChanged(
     Data* data = Data::Get(page_node);
     // Data should have been created when the frame became current.
     DCHECK(data);
-    data->DecrementFrameCountForPolicy(previous_value);
-    data->IncrementFrameCountForPolicy(
+    data->DecrementFrameCountForFreezingPolicy(previous_value);
+    data->IncrementFrameCountForFreezingPolicy(
         frame_node->GetOriginTrialFreezePolicy());
     data->UpdateOriginTrialFreezePolicy(page_node);
   }
 }
 
-void FreezeOriginTrialPolicyAggregator::OnPassedToGraph(Graph* graph) {
+void PageAggregator::OnPassedToGraph(Graph* graph) {
   // This observer presumes that it's been added before any nodes exist in the
   // graph.
   DCHECK(GraphImpl::FromGraph(graph)->nodes().empty());
   graph->AddFrameNodeObserver(this);
 }
 
-void FreezeOriginTrialPolicyAggregator::OnTakenFromGraph(Graph* graph) {
+void PageAggregator::OnTakenFromGraph(Graph* graph) {
   graph->RemoveFrameNodeObserver(this);
 }
 

chrome/browser/performance_manager/decorators/freeze_origin_trial_policy_aggregator.h → chrome/browser/performance_manager/decorators/page_aggregator.h

@@ -2,21 +2,25 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef CHROME_BROWSER_PERFORMANCE_MANAGER_DECORATORS_FREEZE_ORIGIN_TRIAL_POLICY_AGGREGATOR_H_
-#define CHROME_BROWSER_PERFORMANCE_MANAGER_DECORATORS_FREEZE_ORIGIN_TRIAL_POLICY_AGGREGATOR_H_
+#ifndef CHROME_BROWSER_PERFORMANCE_MANAGER_DECORATORS_PAGE_AGGREGATOR_H_
+#define CHROME_BROWSER_PERFORMANCE_MANAGER_DECORATORS_PAGE_AGGREGATOR_H_
 
 #include "chrome/browser/performance_manager/public/graph/frame_node.h"
 #include "chrome/browser/performance_manager/public/graph/graph.h"
 
 namespace performance_manager {
 
-// Computes the freeze origin trial policy of a page by aggregating the freeze
-// origin trial policies of its current frames.
-class FreezeOriginTrialPolicyAggregator : public FrameNode::ObserverDefaultImpl,
-                                          public GraphOwnedDefaultImpl {
+// Computes page level properties. The current properties tracked by this
+// aggregator are:
+//   - The freeze origin trial policy: The aggregation of the freeze
+//     origin trial policies of its current frames.
+//
+// TODO(sebmarchand): Add the WebLocks and IndexedDB properties.
+class PageAggregator : public FrameNode::ObserverDefaultImpl,
+                       public GraphOwnedDefaultImpl {
  public:
-  FreezeOriginTrialPolicyAggregator();
-  ~FreezeOriginTrialPolicyAggregator() override;
+  PageAggregator();
+  ~PageAggregator() override;
 
  private:
   class Data;
@@ -33,9 +37,9 @@ class FreezeOriginTrialPolicyAggregator : public FrameNode::ObserverDefaultImpl,
   void OnPassedToGraph(Graph* graph) override;
   void OnTakenFromGraph(Graph* graph) override;
 
-  DISALLOW_COPY_AND_ASSIGN(FreezeOriginTrialPolicyAggregator);
+  DISALLOW_COPY_AND_ASSIGN(PageAggregator);
 };
 
 }  // namespace performance_manager
 
-#endif  // CHROME_BROWSER_PERFORMANCE_MANAGER_DECORATORS_FREEZE_ORIGIN_TRIAL_POLICY_AGGREGATOR_H_
+#endif  // CHROME_BROWSER_PERFORMANCE_MANAGER_DECORATORS_PAGE_AGGREGATOR_H_

chrome/browser/performance_manager/decorators/freeze_origin_trial_policy_aggregator_unittest.cc → chrome/browser/performance_manager/decorators/page_aggregator_unittest.cc

@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "chrome/browser/performance_manager/decorators/freeze_origin_trial_policy_aggregator.h"
+#include "chrome/browser/performance_manager/decorators/page_aggregator.h"
 
 #include "chrome/browser/performance_manager/graph/frame_node_impl.h"
 #include "chrome/browser/performance_manager/graph/graph_impl_operations.h"
@@ -18,19 +18,20 @@ using resource_coordinator::mojom::InterventionPolicy;
 
 namespace {
 
-class FreezeOriginTrialPolicyAggregatorTest : public GraphTestHarness {
+class PageAggregatorTest : public GraphTestHarness {
  public:
   void SetUp() override {
     GraphTestHarness::SetUp();
-    graph()->PassToGraph(std::make_unique<FreezeOriginTrialPolicyAggregator>());
+    graph()->PassToGraph(std::make_unique<PageAggregator>());
   }
 };
 
-void ExpectInitialPolicyWorks(GraphImpl* mock_graph,
-                              InterventionPolicy f0_policy,
-                              InterventionPolicy f1_policy,
-                              InterventionPolicy f0_policy_aggregated,
-                              InterventionPolicy f0f1_policy_aggregated) {
+void ExpectInitialOriginTrialFreezingPolicyWorks(
+    GraphImpl* mock_graph,
+    InterventionPolicy f0_policy,
+    InterventionPolicy f1_policy,
+    InterventionPolicy f0_policy_aggregated,
+    InterventionPolicy f0f1_policy_aggregated) {
   TestNodeWrapper<ProcessNodeImpl> process =
       TestNodeWrapper<ProcessNodeImpl>::Create(mock_graph);
   TestNodeWrapper<PageNodeImpl> page =
@@ -39,8 +40,8 @@ void ExpectInitialPolicyWorks(GraphImpl* mock_graph,
   // Check the initial values before any frames are added.
   EXPECT_EQ(InterventionPolicy::kDefault, page->origin_trial_freeze_policy());
 
-  // Create an initial frame. Expect the page policy to be
-  // |f0_policy_aggregated| when it is made current.
+  // Create an initial frame. Expect the policy to be |f0_policy_aggregated|
+  // when it is made current.
   TestNodeWrapper<FrameNodeImpl> f0 = TestNodeWrapper<FrameNodeImpl>::Create(
       mock_graph, process.get(), page.get());
   f0->SetOriginTrialFreezePolicy(f0_policy);
@@ -71,32 +72,32 @@ void ExpectInitialPolicyWorks(GraphImpl* mock_graph,
 
 }  // namespace
 
-// Tests all possible combinations of policies for 2 frames. In this test, the
-// policy of a frame is set before it becomes current.
-TEST_F(FreezeOriginTrialPolicyAggregatorTest, InitialPolicy) {
+// Tests all possible combinations of Origin Trial freezing policies for 2
+// frames. In this test, the policy of a frame is set before it becomes current.
+TEST_F(PageAggregatorTest, InitialOriginTrialFreezingPolicy) {
   auto* mock_graph = graph();
 
   // Unknown x [Unknown, Default, OptIn, OptOut]
 
-  ExpectInitialPolicyWorks(
+  ExpectInitialOriginTrialFreezingPolicyWorks(
       mock_graph, InterventionPolicy::kUnknown /* f0_policy */,
       InterventionPolicy::kUnknown /* f1_policy */,
       InterventionPolicy::kUnknown /* f0_policy_aggregated */,
       InterventionPolicy::kUnknown /* f0f1_policy_aggregated */);
 
-  ExpectInitialPolicyWorks(
+  ExpectInitialOriginTrialFreezingPolicyWorks(
       mock_graph, InterventionPolicy::kUnknown /* f0_policy */,
       InterventionPolicy::kDefault /* f1_policy */,
       InterventionPolicy::kUnknown /* f0_policy_aggregated */,
       InterventionPolicy::kUnknown /* f0f1_policy_aggregated */);
 
-  ExpectInitialPolicyWorks(
+  ExpectInitialOriginTrialFreezingPolicyWorks(
       mock_graph, InterventionPolicy::kUnknown /* f0_policy */,
       InterventionPolicy::kOptIn /* f1_policy */,
       InterventionPolicy::kUnknown /* f0_policy_aggregated */,
       InterventionPolicy::kUnknown /* f0f1_policy_aggregated */);
 
-  ExpectInitialPolicyWorks(
+  ExpectInitialOriginTrialFreezingPolicyWorks(
       mock_graph, InterventionPolicy::kUnknown /* f0_policy */,
       InterventionPolicy::kOptOut /* f1_policy */,
       InterventionPolicy::kUnknown /* f0_policy_aggregated */,
@@ -104,25 +105,25 @@ TEST_F(FreezeOriginTrialPolicyAggregatorTest, InitialPolicy) {
 
   // Default x [Unknown, Default, OptIn, OptOut]
 
-  ExpectInitialPolicyWorks(
+  ExpectInitialOriginTrialFreezingPolicyWorks(
       mock_graph, InterventionPolicy::kDefault /* f0_policy */,
       InterventionPolicy::kUnknown /* f1_policy */,
       InterventionPolicy::kDefault /* f0_policy_aggregated */,
       InterventionPolicy::kUnknown /* f0f1_policy_aggregated */);
 
-  ExpectInitialPolicyWorks(
+  ExpectInitialOriginTrialFreezingPolicyWorks(
       mock_graph, InterventionPolicy::kDefault /* f0_policy */,
       InterventionPolicy::kDefault /* f1_policy */,
       InterventionPolicy::kDefault /* f0_policy_aggregated */,
       InterventionPolicy::kDefault /* f0f1_policy_aggregated */);
 
-  ExpectInitialPolicyWorks(
+  ExpectInitialOriginTrialFreezingPolicyWorks(
       mock_graph, InterventionPolicy::kDefault /* f0_policy */,
       InterventionPolicy::kOptIn /* f1_policy */,
       InterventionPolicy::kDefault /* f0_policy_aggregated */,
       InterventionPolicy::kOptIn /* f0f1_policy_aggregated */);
 
-  ExpectInitialPolicyWorks(
+  ExpectInitialOriginTrialFreezingPolicyWorks(
       mock_graph, InterventionPolicy::kDefault /* f0_policy */,
       InterventionPolicy::kOptOut /* f1_policy */,
       InterventionPolicy::kDefault /* f0_policy_aggregated */,
@@ -130,25 +131,25 @@ TEST_F(FreezeOriginTrialPolicyAggregatorTest, InitialPolicy) {
 
   // OptIn x [Unknown, Default, OptIn, OptOut]
 
-  ExpectInitialPolicyWorks(
+  ExpectInitialOriginTrialFreezingPolicyWorks(
       mock_graph, InterventionPolicy::kOptIn /* f0_policy */,
       InterventionPolicy::kUnknown /* f1_policy */,
       InterventionPolicy::kOptIn /* f0_policy_aggregated */,
       InterventionPolicy::kUnknown /* f0f1_policy_aggregated */);
 
-  ExpectInitialPolicyWorks(
+  ExpectInitialOriginTrialFreezingPolicyWorks(
       mock_graph, InterventionPolicy::kOptIn /* f0_policy */,
       InterventionPolicy::kDefault /* f1_policy */,
       InterventionPolicy::kOptIn /* f0_policy_aggregated */,
       InterventionPolicy::kOptIn /* f0f1_policy_aggregated */);
 
-  ExpectInitialPolicyWorks(
+  ExpectInitialOriginTrialFreezingPolicyWorks(
       mock_graph, InterventionPolicy::kOptIn /* f0_policy */,
       InterventionPolicy::kOptIn /* f1_policy */,
       InterventionPolicy::kOptIn /* f0_policy_aggregated */,
       InterventionPolicy::kOptIn /* f0f1_policy_aggregated */);
 
-  ExpectInitialPolicyWorks(
+  ExpectInitialOriginTrialFreezingPolicyWorks(
       mock_graph, InterventionPolicy::kOptIn /* f0_policy */,
       InterventionPolicy::kOptOut /* f1_policy */,
       InterventionPolicy::kOptIn /* f0_policy_aggregated */,
@@ -156,33 +157,34 @@ TEST_F(FreezeOriginTrialPolicyAggregatorTest, InitialPolicy) {
 
   // OptOut x [Unknown, Default, OptIn, OptOut]
 
-  ExpectInitialPolicyWorks(
+  ExpectInitialOriginTrialFreezingPolicyWorks(
       mock_graph, InterventionPolicy::kOptOut /* f0_policy */,
       InterventionPolicy::kUnknown /* f1_policy */,
       InterventionPolicy::kOptOut /* f0_policy_aggregated */,
       InterventionPolicy::kUnknown /* f0f1_policy_aggregated */);
 
-  ExpectInitialPolicyWorks(
+  ExpectInitialOriginTrialFreezingPolicyWorks(
       mock_graph, InterventionPolicy::kOptOut /* f0_policy */,
       InterventionPolicy::kDefault /* f1_policy */,
       InterventionPolicy::kOptOut /* f0_policy_aggregated */,
       InterventionPolicy::kOptOut /* f0f1_policy_aggregated */);
 
-  ExpectInitialPolicyWorks(
+  ExpectInitialOriginTrialFreezingPolicyWorks(
       mock_graph, InterventionPolicy::kOptOut /* f0_policy */,
       InterventionPolicy::kOptIn /* f1_policy */,
       InterventionPolicy::kOptOut /* f0_policy_aggregated */,
       InterventionPolicy::kOptOut /* f0f1_policy_aggregated */);
 
-  ExpectInitialPolicyWorks(
+  ExpectInitialOriginTrialFreezingPolicyWorks(
       mock_graph, InterventionPolicy::kOptOut /* f0_policy */,
       InterventionPolicy::kOptOut /* f1_policy */,
       InterventionPolicy::kOptOut /* f0_policy_aggregated */,
       InterventionPolicy::kOptOut /* f0f1_policy_aggregated */);
 }
 
-// Test changing the policy of a frame after it becomes current.
-TEST_F(FreezeOriginTrialPolicyAggregatorTest, PolicyChanges) {
+// Test changing the Origin Trial Freezing policy of a frame after it becomes
+// current.
+TEST_F(PageAggregatorTest, OriginTrialFreezingPolicyChanges) {
   TestNodeWrapper<ProcessNodeImpl> process =
       TestNodeWrapper<ProcessNodeImpl>::Create(graph());
   TestNodeWrapper<PageNodeImpl> page =

chrome/browser/performance_manager/graph/page_node_impl.h

@@ -106,7 +106,7 @@ class PageNodeImpl
 
  private:
   friend class FrameNodeImpl;
-  friend class FreezeOriginTrialPolicyAggregatorAccess;
+  friend class PageAggregatorAccess;
   friend class FrozenFrameAggregatorAccess;
   friend class PageAlmostIdleAccess;
 
@@ -231,9 +231,8 @@ class PageNodeImpl
   // Inline storage for FrozenFrameAggregator user data.
   InternalNodeAttachedDataStorage<sizeof(uintptr_t) + 8> frozen_frame_data_;
 
-  // Inline storage for FreezeOriginTrialPolicyAggregatorAccess user data.
-  InternalNodeAttachedDataStorage<sizeof(uintptr_t) + 16>
-      freeze_origin_trial_policy_data_;
+  // Inline storage for PageAggregatorAccess user data.
+  InternalNodeAttachedDataStorage<sizeof(uintptr_t) + 16> page_aggregator_data_;
 
   DISALLOW_COPY_AND_ASSIGN(PageNodeImpl);
 };

chrome/browser/performance_manager/graph/page_node_impl_browsertest.cc

@@ -9,7 +9,6 @@
 #include "base/strings/string_util.h"
 #include "base/test/bind_test_util.h"
 #include "base/threading/thread_restrictions.h"
-#include "chrome/browser/performance_manager/decorators/freeze_origin_trial_policy_aggregator.h"
 #include "chrome/browser/performance_manager/graph/page_node_impl.h"
 #include "chrome/browser/performance_manager/performance_manager_impl.h"
 #include "chrome/common/chrome_switches.h"

chrome/test/BUILD.gn

@@ -3083,8 +3083,8 @@ test("unit_tests") {
     "../browser/password_manager/chrome_password_manager_client_unittest.cc",
     "../browser/password_manager/password_store_x_unittest.cc",
     "../browser/payments/payment_handler_permission_context_unittest.cc",
-    "../browser/performance_manager/decorators/freeze_origin_trial_policy_aggregator_unittest.cc",
     "../browser/performance_manager/decorators/frozen_frame_aggregator_unittest.cc",
+    "../browser/performance_manager/decorators/page_aggregator_unittest.cc",
     "../browser/performance_manager/decorators/page_almost_idle_decorator_unittest.cc",
     "../browser/performance_manager/decorators/process_metrics_decorator_unittest.cc",
     "../browser/performance_manager/frame_priority/frame_priority_unittest.cc",