[PM] Add WebLock/IndexedDB lock usage information to the PageNode.

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

chrome/browser/performance_manager/decorators/page_aggregator.cc

@@ -28,6 +28,15 @@ class PageAggregatorAccess {
                                          InterventionPolicy policy) {
     page_node->SetOriginTrialFreezePolicy(policy);
   }
+
+  static void SetPageIsHoldingWebLock(PageNodeImpl* page_node, bool value) {
+    page_node->SetIsHoldingWebLock(value);
+  }
+
+  static void SetPageIsHoldingIndexedDBLock(PageNodeImpl* page_node,
+                                            bool value) {
+    page_node->SetIsHoldingIndexedDBLock(value);
+  }
 };
 
 class PageAggregator::Data : public NodeAttachedDataImpl<Data> {
@@ -36,7 +45,10 @@ class PageAggregator::Data : public NodeAttachedDataImpl<Data> {
   struct Traits : public NodeAttachedDataInternalOnNodeType<PageNodeImpl> {};
 
   explicit Data(const PageNodeImpl* page_node) {}
-  ~Data() override = default;
+  ~Data() override {
+    DCHECK_EQ(num_frames_holding_web_lock_, 0U);
+    DCHECK_EQ(num_frames_holding_indexeddb_lock_, 0U);
+  }
 
   static StorageType* GetInternalStorage(PageNodeImpl* page_node) {
     return PageAggregatorAccess::GetInternalStorage(page_node);
@@ -53,6 +65,17 @@ class PageAggregator::Data : public NodeAttachedDataImpl<Data> {
     --num_current_frames_for_freezing_policy[static_cast<size_t>(policy)];
   }
 
+  // Updates the counter of page using WebLocks and sets the corresponding
+  // page-level property.
+  void UpdateFrameCountForWebLockUsage(bool frame_is_holding_weblock,
+                                       PageNodeImpl* page_node);
+
+  // Updates the counter of page using IndexedDB locks and sets the
+  // corresponding page-level property.
+  void UpdateFrameCountForIndexedDBLockUsage(
+      bool frame_is_holding_indexeddb_lock,
+      PageNodeImpl* page_node);
+
   // Updates the page's origin trial freeze policy from current data.
   void UpdateOriginTrialFreezePolicy(PageNodeImpl* page_node) {
     PageAggregatorAccess::SetOriginTrialFreezePolicy(
@@ -61,19 +84,7 @@ class PageAggregator::Data : public NodeAttachedDataImpl<Data> {
 
  private:
   // Computes the page's origin trial freeze policy from current data.
-  InterventionPolicy ComputeOriginTrialFreezePolicy() const {
-    if (GetNumCurrentFramesForFreezingPolicy(InterventionPolicy::kUnknown))
-      return InterventionPolicy::kUnknown;
-
-    if (GetNumCurrentFramesForFreezingPolicy(InterventionPolicy::kOptOut))
-      return InterventionPolicy::kOptOut;
-
-    if (GetNumCurrentFramesForFreezingPolicy(InterventionPolicy::kOptIn))
-      return InterventionPolicy::kOptIn;
-
-    // A page with no frame can be frozen. This will have no effect.
-    return InterventionPolicy::kDefault;
-  }
+  InterventionPolicy ComputeOriginTrialFreezePolicy() const;
 
   // Returns the number of current frames with |policy| on the page that owns
   // this Data.
@@ -87,9 +98,56 @@ class PageAggregator::Data : public NodeAttachedDataImpl<Data> {
   uint32_t num_current_frames_for_freezing_policy
       [static_cast<size_t>(InterventionPolicy::kMaxValue) + 1] = {};
 
+  // The number of frames holding at least one WebLock / IndexedDB lock. This
+  // counts all frames, not just the current ones.
+  uint32_t num_frames_holding_web_lock_ = 0;
+  uint32_t num_frames_holding_indexeddb_lock_ = 0;
+
   DISALLOW_COPY_AND_ASSIGN(Data);
 };
 
+InterventionPolicy PageAggregator::Data::ComputeOriginTrialFreezePolicy()
+    const {
+  if (GetNumCurrentFramesForFreezingPolicy(InterventionPolicy::kUnknown))
+    return InterventionPolicy::kUnknown;
+
+  if (GetNumCurrentFramesForFreezingPolicy(InterventionPolicy::kOptOut))
+    return InterventionPolicy::kOptOut;
+
+  if (GetNumCurrentFramesForFreezingPolicy(InterventionPolicy::kOptIn))
+    return InterventionPolicy::kOptIn;
+
+  // A page with no frame can be frozen. This will have no effect.
+  return InterventionPolicy::kDefault;
+}
+
+void PageAggregator::Data::UpdateFrameCountForWebLockUsage(
+    bool frame_is_holding_weblock,
+    PageNodeImpl* page_node) {
+  if (frame_is_holding_weblock) {
+    ++num_frames_holding_web_lock_;
+  } else {
+    DCHECK_GT(num_frames_holding_web_lock_, 0U);
+    --num_frames_holding_web_lock_;
+  }
+  PageAggregatorAccess::SetPageIsHoldingWebLock(
+      page_node, num_frames_holding_web_lock_ > 0);
+}
+
+void PageAggregator::Data::UpdateFrameCountForIndexedDBLockUsage(
+    bool frame_is_holding_indexeddb_lock,
+    PageNodeImpl* page_node) {
+  if (frame_is_holding_indexeddb_lock) {
+    ++num_frames_holding_indexeddb_lock_;
+  } else {
+    DCHECK_GT(num_frames_holding_indexeddb_lock_, 0U);
+    --num_frames_holding_indexeddb_lock_;
+  }
+
+  PageAggregatorAccess::SetPageIsHoldingIndexedDBLock(
+      page_node, num_frames_holding_indexeddb_lock_ > 0);
+}
+
 PageAggregator::PageAggregator() = default;
 PageAggregator::~PageAggregator() = default;
 
@@ -98,15 +156,22 @@ void PageAggregator::OnFrameNodeAdded(const FrameNode* frame_node) {
 }
 
 void PageAggregator::OnBeforeFrameNodeRemoved(const FrameNode* frame_node) {
+  auto* page_node = PageNodeImpl::FromNode(frame_node->GetPageNode());
+  Data* data = Data::Get(page_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->DecrementFrameCountForFreezingPolicy(
         frame_node->GetOriginTrialFreezePolicy());
     data->UpdateOriginTrialFreezePolicy(page_node);
   }
+
+  // It is not guaranteed that the graph will be notified that the frame
+  // has released its lock before it is notified of the frame being deleted.
+  if (frame_node->IsHoldingWebLock())
+    data->UpdateFrameCountForWebLockUsage(false, page_node);
+  if (frame_node->IsHoldingIndexedDBLock())
+    data->UpdateFrameCountForIndexedDBLockUsage(false, page_node);
 }
 
 void PageAggregator::OnIsCurrentChanged(const FrameNode* frame_node) {
@@ -128,7 +193,8 @@ void PageAggregator::OnOriginTrialFreezePolicyChanged(
   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.
+    // Data should have been created when the frame became current or the first
+    // time this frame grabbed a lock.
     DCHECK(data);
     data->DecrementFrameCountForFreezingPolicy(previous_value);
     data->IncrementFrameCountForFreezingPolicy(
@@ -137,6 +203,22 @@ void PageAggregator::OnOriginTrialFreezePolicyChanged(
   }
 }
 
+void PageAggregator::OnFrameIsHoldingWebLockChanged(
+    const FrameNode* frame_node) {
+  auto* page_node = PageNodeImpl::FromNode(frame_node->GetPageNode());
+  Data* data = Data::GetOrCreate(page_node);
+  data->UpdateFrameCountForWebLockUsage(frame_node->IsHoldingWebLock(),
+                                        page_node);
+}
+
+void PageAggregator::OnFrameIsHoldingIndexedDBLockChanged(
+    const FrameNode* frame_node) {
+  auto* page_node = PageNodeImpl::FromNode(frame_node->GetPageNode());
+  Data* data = Data::GetOrCreate(page_node);
+  data->UpdateFrameCountForIndexedDBLockUsage(
+      frame_node->IsHoldingIndexedDBLock(), page_node);
+}
+
 void PageAggregator::OnPassedToGraph(Graph* graph) {
   // This observer presumes that it's been added before any nodes exist in the
   // graph.

chrome/browser/performance_manager/decorators/page_aggregator.h

@@ -14,8 +14,8 @@ namespace performance_manager {
 // 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.
+//   - The usage of WebLocks in one of the page's frames.
+//   - The usage of IndexedDB locks in one of the page's frames.
 class PageAggregator : public FrameNode::ObserverDefaultImpl,
                        public GraphOwnedDefaultImpl {
  public:
@@ -32,6 +32,9 @@ class PageAggregator : public FrameNode::ObserverDefaultImpl,
   void OnOriginTrialFreezePolicyChanged(
       const FrameNode* frame_node,
       const InterventionPolicy& previous_value) override;
+  void OnFrameIsHoldingWebLockChanged(const FrameNode* frame_node) override;
+  void OnFrameIsHoldingIndexedDBLockChanged(
+      const FrameNode* frame_node) override;
 
   // GraphOwned implementation:
   void OnPassedToGraph(Graph* graph) override;

chrome/browser/performance_manager/decorators/page_aggregator_unittest.cc

@@ -185,10 +185,8 @@ TEST_F(PageAggregatorTest, InitialOriginTrialFreezingPolicy) {
 // 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 =
-      TestNodeWrapper<PageNodeImpl>::Create(graph());
+  auto process = CreateNode<ProcessNodeImpl>();
+  auto page = CreateNode<PageNodeImpl>();
   TestNodeWrapper<FrameNodeImpl> frame =
       graph()->CreateFrameNodeAutoId(process.get(), page.get());
   frame->SetIsCurrent(true);
@@ -204,4 +202,67 @@ TEST_F(PageAggregatorTest, OriginTrialFreezingPolicyChanges) {
   EXPECT_EQ(InterventionPolicy::kUnknown, page->origin_trial_freeze_policy());
 }
 
+TEST_F(PageAggregatorTest, WebLocksAggregation) {
+  // Creates a page containing 2 frames.
+  auto process = CreateNode<ProcessNodeImpl>();
+  auto page = CreateNode<PageNodeImpl>();
+  TestNodeWrapper<FrameNodeImpl> frame_0 =
+      graph()->CreateFrameNodeAutoId(process.get(), page.get());
+  TestNodeWrapper<FrameNodeImpl> frame_1 =
+      graph()->CreateFrameNodeAutoId(process.get(), page.get());
+
+  // By default the page shouldn't hold any WebLock.
+  EXPECT_FALSE(page->is_holding_weblock());
+
+  // |frame_0| now holds a WebLock, the corresponding property should be set on
+  // the page node.
+  frame_0->SetIsHoldingWebLock(true);
+  EXPECT_TRUE(page->is_holding_weblock());
+
+  // |frame_1| also holding a WebLock shouldn't affect the page property.
+  frame_1->SetIsHoldingWebLock(true);
+  EXPECT_TRUE(page->is_holding_weblock());
+
+  // |frame_1| still holds a WebLock after this.
+  frame_0->SetIsHoldingWebLock(false);
+  EXPECT_TRUE(page->is_holding_weblock());
+
+  // Destroying |frame_1| without explicitly releasing the WebLock it's
+  // holding should update the corresponding page property.
+  frame_1.reset();
+  EXPECT_FALSE(page->is_holding_weblock());
+}
+
+TEST_F(PageAggregatorTest, IndexedDBLocksAggregation) {
+  // Creates a page containing 2 frames.
+  auto process = CreateNode<ProcessNodeImpl>();
+  auto page = CreateNode<PageNodeImpl>();
+  TestNodeWrapper<FrameNodeImpl> frame_0 =
+      graph()->CreateFrameNodeAutoId(process.get(), page.get());
+  TestNodeWrapper<FrameNodeImpl> frame_1 =
+      graph()->CreateFrameNodeAutoId(process.get(), page.get());
+
+  // By default the page shouldn't hold any IndexedDB lock.
+  EXPECT_FALSE(page->is_holding_indexeddb_lock());
+
+  // |frame_0| now holds an IndexedDB lock, the corresponding property should be
+  // set on the page node.
+  frame_0->SetIsHoldingIndexedDBLock(true);
+  EXPECT_TRUE(page->is_holding_indexeddb_lock());
+
+  // |frame_1| also holding an IndexedDB lock shouldn't affect the page
+  // property.
+  frame_1->SetIsHoldingIndexedDBLock(true);
+  EXPECT_TRUE(page->is_holding_indexeddb_lock());
+
+  // |frame_1| still holds an IndexedDB lock after this.
+  frame_0->SetIsHoldingIndexedDBLock(false);
+  EXPECT_TRUE(page->is_holding_indexeddb_lock());
+
+  // Destroying |frame_1| without explicitly releasing the IndexedDB lock it's
+  // holding should update the corresponding page property.
+  frame_1.reset();
+  EXPECT_FALSE(page->is_holding_indexeddb_lock());
+}
+
 }  // namespace performance_manager

chrome/browser/ui/webui/discards/graph_dump_impl.h

@@ -75,10 +75,10 @@ class DiscardsGraphDumpImpl : public discards::mojom::GraphDump,
   void OnIsAdFrameChanged(
       const performance_manager::FrameNode* frame_node) override {}
   // Ignored.
-  void OnFrameHoldsWebLockChanged(
+  void OnFrameIsHoldingWebLockChanged(
       const performance_manager::FrameNode* frame_node) override {}
   // Ignored.
-  void OnFrameHoldsIndexedDBLockChanged(
+  void OnFrameIsHoldingIndexedDBLockChanged(
       const performance_manager::FrameNode* frame_node) override {}
   // Ignored.
   void OnNonPersistentNotificationCreated(
@@ -105,6 +105,12 @@ class DiscardsGraphDumpImpl : public discards::mojom::GraphDump,
   // Ignored.
   void OnPageOriginTrialFreezePolicyChanged(
       const performance_manager::PageNode* page_node) override {}
+  // Ignored.
+  void OnPageIsHoldingWebLockChanged(
+      const performance_manager::PageNode* page_node) override {}
+  // Ignored.
+  void OnPageIsHoldingIndexedDBLockChanged(
+      const performance_manager::PageNode* page_node) override {}
   void OnMainFrameUrlChanged(
       const performance_manager::PageNode* page_node) override;
   // Ignored.

components/performance_manager/graph/frame_node_impl.cc

@@ -167,14 +167,14 @@ bool FrameNodeImpl::is_ad_frame() const {
   return is_ad_frame_.value();
 }
 
-bool FrameNodeImpl::holds_web_lock() const {
+bool FrameNodeImpl::is_holding_weblock() const {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
-  return holds_web_lock_.value();
+  return is_holding_weblock_.value();
 }
 
-bool FrameNodeImpl::holds_indexed_db_lock() const {
+bool FrameNodeImpl::is_holding_indexeddb_lock() const {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
-  return holds_indexed_db_lock_.value();
+  return is_holding_indexeddb_lock_.value();
 }
 
 const base::flat_set<WorkerNodeImpl*>& FrameNodeImpl::child_worker_nodes()
@@ -214,16 +214,16 @@ void FrameNodeImpl::SetIsCurrent(bool is_current) {
 #endif
 }
 
-void FrameNodeImpl::SetHoldsWebLock(bool holds_web_lock) {
+void FrameNodeImpl::SetIsHoldingWebLock(bool is_holding_weblock) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
-  DCHECK_NE(holds_web_lock, holds_web_lock_.value());
-  holds_web_lock_.SetAndMaybeNotify(this, holds_web_lock);
+  DCHECK_NE(is_holding_weblock, is_holding_weblock_.value());
+  is_holding_weblock_.SetAndMaybeNotify(this, is_holding_weblock);
 }
 
-void FrameNodeImpl::SetHoldsIndexedDBLock(bool holds_indexed_db_lock) {
+void FrameNodeImpl::SetIsHoldingIndexedDBLock(bool is_holding_indexeddb_lock) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
-  DCHECK_NE(holds_indexed_db_lock, holds_indexed_db_lock_.value());
-  holds_indexed_db_lock_.SetAndMaybeNotify(this, holds_indexed_db_lock);
+  DCHECK_NE(is_holding_indexeddb_lock, is_holding_indexeddb_lock_.value());
+  is_holding_indexeddb_lock_.SetAndMaybeNotify(this, is_holding_indexeddb_lock);
 }
 
 void FrameNodeImpl::OnNavigationCommitted(const GURL& url, bool same_document) {
@@ -361,14 +361,14 @@ bool FrameNodeImpl::IsAdFrame() const {
   return is_ad_frame();
 }
 
-bool FrameNodeImpl::HoldsWebLock() const {
+bool FrameNodeImpl::IsHoldingWebLock() const {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
-  return holds_web_lock();
+  return is_holding_weblock();
 }
 
-bool FrameNodeImpl::HoldsIndexedDBLock() const {
+bool FrameNodeImpl::IsHoldingIndexedDBLock() const {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
-  return holds_indexed_db_lock();
+  return is_holding_indexeddb_lock();
 }
 
 const base::flat_set<const WorkerNode*> FrameNodeImpl::GetChildWorkerNodes()

components/performance_manager/graph/frame_node_impl.h

@@ -101,15 +101,15 @@ class FrameNodeImpl
   bool is_current() const;
   bool network_almost_idle() const;
   bool is_ad_frame() const;
-  bool holds_web_lock() const;
-  bool holds_indexed_db_lock() const;
+  bool is_holding_weblock() const;
+  bool is_holding_indexeddb_lock() const;
   const base::flat_set<WorkerNodeImpl*>& child_worker_nodes() const;
   const PriorityAndReason& priority_and_reason() const;
 
   // Setters are not thread safe.
   void SetIsCurrent(bool is_current);
-  void SetHoldsWebLock(bool holds_web_lock);
-  void SetHoldsIndexedDBLock(bool holds_indexed_db_lock);
+  void SetIsHoldingWebLock(bool is_holding_weblock);
+  void SetIsHoldingIndexedDBLock(bool is_holding_indexeddb_lock);
 
   // Invoked when a navigation is committed in the frame.
   void OnNavigationCommitted(const GURL& url, bool same_document);
@@ -142,8 +142,8 @@ class FrameNodeImpl
   bool IsCurrent() const override;
   bool GetNetworkAlmostIdle() const override;
   bool IsAdFrame() const override;
-  bool HoldsWebLock() const override;
-  bool HoldsIndexedDBLock() const override;
+  bool IsHoldingWebLock() const override;
+  bool IsHoldingIndexedDBLock() const override;
   const base::flat_set<const WorkerNode*> GetChildWorkerNodes() const override;
   const PriorityAndReason& GetPriorityAndReason() const override;
 
@@ -230,12 +230,12 @@ class FrameNodeImpl
   // subsystems after a navigation for locks to be released).
   ObservedProperty::NotifiesOnlyOnChanges<
       bool,
-      &FrameNodeObserver::OnFrameHoldsWebLockChanged>
-      holds_web_lock_{false};
+      &FrameNodeObserver::OnFrameIsHoldingWebLockChanged>
+      is_holding_weblock_{false};
   ObservedProperty::NotifiesOnlyOnChanges<
       bool,
-      &FrameNodeObserver::OnFrameHoldsIndexedDBLockChanged>
-      holds_indexed_db_lock_{false};
+      &FrameNodeObserver::OnFrameIsHoldingIndexedDBLockChanged>
+      is_holding_indexeddb_lock_{false};
 
   ObservedProperty::
       NotifiesOnlyOnChanges<bool, &FrameNodeObserver::OnIsCurrentChanged>

components/performance_manager/graph/frame_node_impl_unittest.cc

@@ -132,8 +132,8 @@ class LenientMockObserver : public FrameNodeImpl::Observer {
                     const resource_coordinator::mojom::InterventionPolicy&));
   MOCK_METHOD2(OnURLChanged, void(const FrameNode*, const GURL&));
   MOCK_METHOD1(OnIsAdFrameChanged, void(const FrameNode*));
-  MOCK_METHOD1(OnFrameHoldsWebLockChanged, void(const FrameNode*));
-  MOCK_METHOD1(OnFrameHoldsIndexedDBLockChanged, void(const FrameNode*));
+  MOCK_METHOD1(OnFrameIsHoldingWebLockChanged, void(const FrameNode*));
+  MOCK_METHOD1(OnFrameIsHoldingIndexedDBLockChanged, void(const FrameNode*));
   MOCK_METHOD1(OnNonPersistentNotificationCreated, void(const FrameNode*));
   MOCK_METHOD1(OnPriorityAndReasonChanged, void(const FrameNode*));
 
@@ -225,7 +225,7 @@ TEST_F(FrameNodeImplTest, IsAdFrame) {
   graph()->RemoveFrameNodeObserver(&obs);
 }
 
-TEST_F(FrameNodeImplTest, HoldsWebLock) {
+TEST_F(FrameNodeImplTest, IsHoldingWebLock) {
   auto process = CreateNode<ProcessNodeImpl>();
   auto page = CreateNode<PageNodeImpl>();
   auto frame_node = CreateFrameNodeAutoId(process.get(), page.get());
@@ -233,18 +233,18 @@ TEST_F(FrameNodeImplTest, HoldsWebLock) {
   MockObserver obs;
   graph()->AddFrameNodeObserver(&obs);
 
-  EXPECT_FALSE(frame_node->holds_web_lock());
-  EXPECT_CALL(obs, OnFrameHoldsWebLockChanged(frame_node.get()));
-  frame_node->SetHoldsWebLock(true);
-  EXPECT_TRUE(frame_node->holds_web_lock());
-  EXPECT_CALL(obs, OnFrameHoldsWebLockChanged(frame_node.get()));
-  frame_node->SetHoldsWebLock(false);
-  EXPECT_FALSE(frame_node->holds_web_lock());
+  EXPECT_FALSE(frame_node->is_holding_weblock());
+  EXPECT_CALL(obs, OnFrameIsHoldingWebLockChanged(frame_node.get()));
+  frame_node->SetIsHoldingWebLock(true);
+  EXPECT_TRUE(frame_node->is_holding_weblock());
+  EXPECT_CALL(obs, OnFrameIsHoldingWebLockChanged(frame_node.get()));
+  frame_node->SetIsHoldingWebLock(false);
+  EXPECT_FALSE(frame_node->is_holding_weblock());
 
   graph()->RemoveFrameNodeObserver(&obs);
 }
 
-TEST_F(FrameNodeImplTest, HoldsIndexedDBLock) {
+TEST_F(FrameNodeImplTest, IsHoldingIndexedDBLock) {
   auto process = CreateNode<ProcessNodeImpl>();
   auto page = CreateNode<PageNodeImpl>();
   auto frame_node = CreateFrameNodeAutoId(process.get(), page.get());
@@ -252,13 +252,12 @@ TEST_F(FrameNodeImplTest, HoldsIndexedDBLock) {
   MockObserver obs;
   graph()->AddFrameNodeObserver(&obs);
 
-  EXPECT_FALSE(frame_node->holds_indexed_db_lock());
-  EXPECT_CALL(obs, OnFrameHoldsIndexedDBLockChanged(frame_node.get()));
-  frame_node->SetHoldsIndexedDBLock(true);
-  EXPECT_TRUE(frame_node->holds_indexed_db_lock());
-  EXPECT_CALL(obs, OnFrameHoldsIndexedDBLockChanged(frame_node.get()));
-  frame_node->SetHoldsIndexedDBLock(false);
-  EXPECT_FALSE(frame_node->holds_indexed_db_lock());
+  EXPECT_CALL(obs, OnFrameIsHoldingIndexedDBLockChanged(frame_node.get()));
+  frame_node->SetIsHoldingIndexedDBLock(true);
+  EXPECT_TRUE(frame_node->is_holding_indexeddb_lock());
+  EXPECT_CALL(obs, OnFrameIsHoldingIndexedDBLockChanged(frame_node.get()));
+  frame_node->SetIsHoldingIndexedDBLock(false);
+  EXPECT_FALSE(frame_node->is_holding_indexeddb_lock());
 
   graph()->RemoveFrameNodeObserver(&obs);
 }
@@ -353,9 +352,10 @@ TEST_F(FrameNodeImplTest, PublicInterface) {
   EXPECT_EQ(frame_node->network_almost_idle(),
             public_frame_node->GetNetworkAlmostIdle());
   EXPECT_EQ(frame_node->is_ad_frame(), public_frame_node->IsAdFrame());
-  EXPECT_EQ(frame_node->holds_web_lock(), public_frame_node->HoldsWebLock());
-  EXPECT_EQ(frame_node->holds_indexed_db_lock(),
-            public_frame_node->HoldsIndexedDBLock());
+  EXPECT_EQ(frame_node->is_holding_weblock(),
+            public_frame_node->IsHoldingWebLock());
+  EXPECT_EQ(frame_node->is_holding_indexeddb_lock(),
+            public_frame_node->IsHoldingIndexedDBLock());
 }
 
 }  // namespace performance_manager

components/performance_manager/graph/page_node_impl.cc

@@ -195,6 +195,16 @@ PageNodeImpl::InterventionPolicy PageNodeImpl::origin_trial_freeze_policy()
   return origin_trial_freeze_policy_.value();
 }
 
+bool PageNodeImpl::is_holding_weblock() const {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
+  return is_holding_weblock_.value();
+}
+
+bool PageNodeImpl::is_holding_indexeddb_lock() const {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
+  return is_holding_indexeddb_lock_.value();
+}
+
 const base::flat_set<FrameNodeImpl*>& PageNodeImpl::main_frame_nodes() const {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   return main_frame_nodes_;
@@ -319,6 +329,16 @@ PageNodeImpl::InterventionPolicy PageNodeImpl::GetOriginTrialFreezePolicy()
   return origin_trial_freeze_policy();
 }
 
+bool PageNodeImpl::IsHoldingWebLock() const {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
+  return is_holding_weblock();
+}
+
+bool PageNodeImpl::IsHoldingIndexedDBLock() const {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
+  return is_holding_indexeddb_lock();
+}
+
 int64_t PageNodeImpl::GetNavigationID() const {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   return navigation_id();
@@ -364,4 +384,14 @@ void PageNodeImpl::SetOriginTrialFreezePolicy(InterventionPolicy policy) {
   origin_trial_freeze_policy_.SetAndMaybeNotify(this, policy);
 }
 
+void PageNodeImpl::SetIsHoldingWebLock(bool is_holding_weblock) {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
+  is_holding_weblock_.SetAndMaybeNotify(this, is_holding_weblock);
+}
+
+void PageNodeImpl::SetIsHoldingIndexedDBLock(bool is_holding_indexeddb_lock) {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
+  is_holding_indexeddb_lock_.SetAndMaybeNotify(this, is_holding_indexeddb_lock);
+}
+
 }  // namespace performance_manager

components/performance_manager/graph/page_node_impl.h

@@ -81,6 +81,8 @@ class PageNodeImpl
   ukm::SourceId ukm_source_id() const;
   LifecycleState lifecycle_state() const;
   InterventionPolicy origin_trial_freeze_policy() const;
+  bool is_holding_weblock() const;
+  bool is_holding_indexeddb_lock() const;
   const base::flat_set<FrameNodeImpl*>& main_frame_nodes() const;
   base::TimeTicks usage_estimate_time() const;
   base::TimeDelta cumulative_cpu_usage_estimate() const;
@@ -120,6 +122,8 @@ class PageNodeImpl
   ukm::SourceId GetUkmSourceID() const override;
   LifecycleState GetLifecycleState() const override;
   InterventionPolicy GetOriginTrialFreezePolicy() const override;
+  bool IsHoldingWebLock() const override;
+  bool IsHoldingIndexedDBLock() const override;
   int64_t GetNavigationID() const override;
   base::TimeDelta GetTimeSinceLastNavigation() const override;
   const FrameNode* GetMainFrameNode() const override;
@@ -135,6 +139,8 @@ class PageNodeImpl
   void SetPageAlmostIdle(bool page_almost_idle);
   void SetLifecycleState(LifecycleState lifecycle_state);
   void SetOriginTrialFreezePolicy(InterventionPolicy policy);
+  void SetIsHoldingWebLock(bool is_holding_weblock);
+  void SetIsHoldingIndexedDBLock(bool is_holding_indexeddb_lock);
 
   // The WebContentsProxy associated with this page.
   const WebContentsProxy contents_proxy_;
@@ -224,6 +230,17 @@ class PageNodeImpl
       InterventionPolicy,
       &PageNodeObserver::OnPageOriginTrialFreezePolicyChanged>
       origin_trial_freeze_policy_{InterventionPolicy::kDefault};
+  // Indicates if at least one frame of the page is currently holding a WebLock.
+  ObservedProperty::NotifiesOnlyOnChanges<
+      bool,
+      &PageNodeObserver::OnPageIsHoldingWebLockChanged>
+      is_holding_weblock_{false};
+  // Indicates if at least one frame of the page is currently holding an
+  // IndexedDB lock.
+  ObservedProperty::NotifiesOnlyOnChanges<
+      bool,
+      &PageNodeObserver::OnPageIsHoldingIndexedDBLockChanged>
+      is_holding_indexeddb_lock_{false};
 
   // Storage for PageAlmostIdle user data.
   std::unique_ptr<NodeAttachedData> page_almost_idle_data_;
@@ -232,7 +249,7 @@ class PageNodeImpl
   InternalNodeAttachedDataStorage<sizeof(uintptr_t) + 8> frozen_frame_data_;
 
   // Inline storage for PageAggregatorAccess user data.
-  InternalNodeAttachedDataStorage<sizeof(uintptr_t) + 16> page_aggregator_data_;
+  InternalNodeAttachedDataStorage<sizeof(uintptr_t) + 24> page_aggregator_data_;
 
   DISALLOW_COPY_AND_ASSIGN(PageNodeImpl);
 };

components/performance_manager/graph/page_node_impl_unittest.cc

@@ -198,6 +198,8 @@ class LenientMockObserver : public PageNodeImpl::Observer {
   MOCK_METHOD1(OnUkmSourceIdChanged, void(const PageNode*));
   MOCK_METHOD1(OnPageLifecycleStateChanged, void(const PageNode*));
   MOCK_METHOD1(OnPageOriginTrialFreezePolicyChanged, void(const PageNode*));
+  MOCK_METHOD1(OnPageIsHoldingWebLockChanged, void(const PageNode*));
+  MOCK_METHOD1(OnPageIsHoldingIndexedDBLockChanged, void(const PageNode*));
   MOCK_METHOD1(OnMainFrameUrlChanged, void(const PageNode*));
   MOCK_METHOD1(OnPageAlmostIdleChanged, void(const PageNode*));
   MOCK_METHOD1(OnMainFrameDocumentChanged, void(const PageNode*));

components/performance_manager/performance_manager_lock_observer.cc

@@ -12,14 +12,14 @@ namespace performance_manager {
 
 namespace {
 
-void SetHoldsWebLock(int render_process_id,
-                     int render_frame_id,
-                     bool holds_web_lock,
-                     GraphImpl* graph) {
+void SetIsHoldingWebLock(int render_process_id,
+                         int render_frame_id,
+                         bool is_holding_web_lock,
+                         GraphImpl* graph) {
   FrameNodeImpl* frame_node =
       graph->GetFrameNodeById(render_process_id, render_frame_id);
   if (frame_node)
-    frame_node->SetHoldsWebLock(holds_web_lock);
+    frame_node->SetIsHoldingWebLock(is_holding_web_lock);
 }
 
 }  // namespace
@@ -31,7 +31,7 @@ void PerformanceManagerLockObserver::OnFrameStartsHoldingWebLocks(
     int render_process_id,
     int render_frame_id) {
   PerformanceManagerImpl::CallOnGraphImpl(
-      FROM_HERE, base::BindOnce(&SetHoldsWebLock, render_process_id,
+      FROM_HERE, base::BindOnce(&SetIsHoldingWebLock, render_process_id,
                                 render_frame_id, true));
 }
 
@@ -39,7 +39,7 @@ void PerformanceManagerLockObserver::OnFrameStopsHoldingWebLocks(
     int render_process_id,
     int render_frame_id) {
   PerformanceManagerImpl::CallOnGraphImpl(
-      FROM_HERE, base::BindOnce(&SetHoldsWebLock, render_process_id,
+      FROM_HERE, base::BindOnce(&SetIsHoldingWebLock, render_process_id,
                                 render_frame_id, false));
 }
 

components/performance_manager/public/graph/frame_node.h

@@ -132,11 +132,11 @@ class FrameNode : public Node {
   virtual bool IsAdFrame() const = 0;
 
   // Returns true if this frame holds at least one Web Lock.
-  virtual bool HoldsWebLock() const = 0;
+  virtual bool IsHoldingWebLock() const = 0;
 
   // Returns true if this frame holds at least one IndexedDB lock. An IndexedDB
   // lock is held by an active transaction or an active DB open request.
-  virtual bool HoldsIndexedDBLock() const = 0;
+  virtual bool IsHoldingIndexedDBLock() const = 0;
 
   // Returns the child workers of this frame. These are either dedicated workers
   // or shared workers created by this frame, or a service worker that handles
@@ -192,11 +192,11 @@ class FrameNodeObserver {
   // Invoked when the IsAdFrame property changes.
   virtual void OnIsAdFrameChanged(const FrameNode* frame_node) = 0;
 
-  // Invoked when the HoldsWebLock() property changes.
-  virtual void OnFrameHoldsWebLockChanged(const FrameNode* frame_node) = 0;
+  // Invoked when the IsHoldingWebLock() property changes.
+  virtual void OnFrameIsHoldingWebLockChanged(const FrameNode* frame_node) = 0;
 
-  // Invoked when the HoldsIndexedDBLock() property changes.
-  virtual void OnFrameHoldsIndexedDBLockChanged(
+  // Invoked when the IsHoldingIndexedDBLock() property changes.
+  virtual void OnFrameIsHoldingIndexedDBLockChanged(
       const FrameNode* frame_node) = 0;
 
   // Invoked when the frame priority and reason changes.
@@ -232,8 +232,9 @@ class FrameNode::ObserverDefaultImpl : public FrameNodeObserver {
   void OnURLChanged(const FrameNode* frame_node,
                     const GURL& previous_value) override {}
   void OnIsAdFrameChanged(const FrameNode* frame_node) override {}
-  void OnFrameHoldsWebLockChanged(const FrameNode* frame_node) override {}
-  void OnFrameHoldsIndexedDBLockChanged(const FrameNode* frame_node) override {}
+  void OnFrameIsHoldingWebLockChanged(const FrameNode* frame_node) override {}
+  void OnFrameIsHoldingIndexedDBLockChanged(
+      const FrameNode* frame_node) override {}
   void OnNonPersistentNotificationCreated(
       const FrameNode* frame_node) override {}
   void OnPriorityAndReasonChanged(const FrameNode* frame_node) override {}

components/performance_manager/public/graph/page_node.h

@@ -71,6 +71,14 @@ class PageNode : public Node {
   // Returns the freeze policy set via origin trial.
   virtual InterventionPolicy GetOriginTrialFreezePolicy() const = 0;
 
+  // Returns true if at least one of the frame in this page is currently
+  // holding a WebLock.
+  virtual bool IsHoldingWebLock() const = 0;
+
+  // Returns true if at least one of the frame in this page is currently
+  // holding an IndexedDB lock.
+  virtual bool IsHoldingIndexedDBLock() const = 0;
+
   // Returns the navigation ID associated with the last committed navigation
   // event for the main frame of this page.
   // See PageNodeObserver::OnMainFrameNavigationCommitted.
@@ -140,6 +148,13 @@ class PageNodeObserver {
   virtual void OnPageOriginTrialFreezePolicyChanged(
       const PageNode* page_node) = 0;
 
+  // Invoked when the IsHoldingWebLock property changes.
+  virtual void OnPageIsHoldingWebLockChanged(const PageNode* page_node) = 0;
+
+  // Invoked when the IsHoldingIndexedDBLock property changes.
+  virtual void OnPageIsHoldingIndexedDBLockChanged(
+      const PageNode* page_node) = 0;
+
   // Invoked when the MainFrameUrl property changes.
   virtual void OnMainFrameUrlChanged(const PageNode* page_node) = 0;
 
@@ -183,6 +198,9 @@ class PageNode::ObserverDefaultImpl : public PageNodeObserver {
   void OnPageLifecycleStateChanged(const PageNode* page_node) override {}
   void OnPageOriginTrialFreezePolicyChanged(
       const PageNode* page_node) override {}
+  void OnPageIsHoldingWebLockChanged(const PageNode* page_node) override {}
+  void OnPageIsHoldingIndexedDBLockChanged(const PageNode* page_node) override {
+  }
   void OnPageAlmostIdleChanged(const PageNode* page_node) override {}
   void OnMainFrameUrlChanged(const PageNode* page_node) override {}
   void OnMainFrameDocumentChanged(const PageNode* page_node) override {}