PM: Remove unused CPU-related node properties.

These are orphans from an earlier, now-abandoned implementation.

Bug: 755840
Change-Id: If649f858655b4babe3cdda3d9467174b12f24ff6
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2090140Reviewed-by: Joe Mason <joenotcharles@chromium.org>
Reviewed-by: Will Harris <wfh@chromium.org>
Commit-Queue: Will Harris <wfh@chromium.org>
Auto-Submit: Sigurður Ásgeirsson <siggi@chromium.org>
Cr-Commit-Position: refs/heads/master@{#747816}

chrome/browser/ui/webui/discards/discards.mojom

@@ -202,7 +202,6 @@ struct ProcessInfo {
   int64 id;
 
   mojo_base.mojom.ProcessId pid;
-  mojo_base.mojom.TimeDelta cumulative_cpu_usage;
   uint64 private_footprint_kb;
 };
 

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

@@ -403,7 +403,6 @@ void DiscardsGraphDumpImpl::SendProcessNotification(
 
   process_info->id = GetSerializationId(process);
   process_info->pid = process->GetProcessId();
-  process_info->cumulative_cpu_usage = process->GetCumulativeCpuUsage();
   process_info->private_footprint_kb = process->GetPrivateFootprintKb();
 
   if (created)

components/performance_manager/graph/page_node_impl.cc

@@ -122,22 +122,6 @@ void PageNodeImpl::OnMainFrameNavigationCommitted(
     observer->OnMainFrameDocumentChanged(this);
 }
 
-double PageNodeImpl::GetCPUUsage() const {
-  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
-  double cpu_usage = 0;
-
-  // TODO(chrisha/siggi): This should all be ripped out / refactored.
-  for (auto* process_node :
-       GraphImplOperations::GetAssociatedProcessNodes(this)) {
-    size_t pages_in_process =
-        GraphImplOperations::GetAssociatedPageNodes(process_node).size();
-    DCHECK_LE(1u, pages_in_process);
-    cpu_usage += process_node->cpu_usage() / pages_in_process;
-  }
-
-  return cpu_usage;
-}
-
 base::TimeDelta PageNodeImpl::TimeSinceLastNavigation() const {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   if (navigation_committed_time_.is_null())
@@ -217,11 +201,6 @@ base::TimeTicks PageNodeImpl::usage_estimate_time() const {
   return usage_estimate_time_;
 }
 
-base::TimeDelta PageNodeImpl::cumulative_cpu_usage_estimate() const {
-  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
-  return cumulative_cpu_usage_estimate_;
-}
-
 uint64_t PageNodeImpl::private_footprint_kb_estimate() const {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   return private_footprint_kb_estimate_;
@@ -258,12 +237,6 @@ void PageNodeImpl::set_usage_estimate_time(
   usage_estimate_time_ = usage_estimate_time;
 }
 
-void PageNodeImpl::set_cumulative_cpu_usage_estimate(
-    base::TimeDelta cumulative_cpu_usage_estimate) {
-  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
-  cumulative_cpu_usage_estimate_ = cumulative_cpu_usage_estimate;
-}
-
 void PageNodeImpl::set_private_footprint_kb_estimate(
     uint64_t private_footprint_kb_estimate) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);

components/performance_manager/graph/page_node_impl.h

@@ -54,13 +54,6 @@ class PageNodeImpl
                                       const GURL& url,
                                       const std::string& contents_mime_type);
 
-  // Returns the average CPU usage that can be attributed to this page over the
-  // last measurement period. CPU usage is expressed as the average percentage
-  // of cores occupied over the last measurement interval. One core fully
-  // occupied would be 100, while two cores at 5% each would be 10.
-  // TODO(chrisha): Make this 1.0 for 100%, and 0.1 for 10%.
-  double GetCPUUsage() const;
-
   // Returns 0 if no navigation has happened, otherwise returns the time since
   // the last navigation commit.
   base::TimeDelta TimeSinceLastNavigation() const;
@@ -87,7 +80,6 @@ class PageNodeImpl
   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;
   uint64_t private_footprint_kb_estimate() const;
   const GURL& main_frame_url() const;
   int64_t navigation_id() const;
@@ -95,8 +87,6 @@ class PageNodeImpl
   bool had_form_interaction() const;
 
   void set_usage_estimate_time(base::TimeTicks usage_estimate_time);
-  void set_cumulative_cpu_usage_estimate(
-      base::TimeDelta cumulative_cpu_usage_estimate);
   void set_private_footprint_kb_estimate(
       uint64_t private_footprint_kb_estimate);
   void set_has_nonempty_beforeunload(bool has_nonempty_beforeunload);
@@ -175,14 +165,6 @@ class PageNodeImpl
   // The time the most recent resource usage estimate applies to.
   base::TimeTicks usage_estimate_time_;
 
-  // The most current CPU usage estimate. Note that this estimate is most
-  // generously described as "piecewise linear", as it attributes the CPU
-  // cost incurred since the last measurement was made equally to pages
-  // hosted by a process. If, e.g. a frame has come into existence and vanished
-  // from a given process between measurements, the entire cost to that frame
-  // will be mis-attributed to other frames hosted in that process.
-  base::TimeDelta cumulative_cpu_usage_estimate_;
-
   // The most current memory footprint estimate.
   uint64_t private_footprint_kb_estimate_ = 0;
 

components/performance_manager/graph/page_node_impl_unittest.cc

@@ -73,36 +73,6 @@ TEST_F(PageNodeImplTest, RemoveFrame) {
   EXPECT_EQ(0u, GraphImplOperations::GetFrameNodes(page_node.get()).size());
 }
 
-TEST_F(PageNodeImplTest, CalculatePageCPUUsageForSinglePageInSingleProcess) {
-  MockSinglePageInSingleProcessGraph mock_graph(graph());
-  mock_graph.process->SetCPUUsage(40);
-  EXPECT_EQ(40, mock_graph.page->GetCPUUsage());
-}
-
-TEST_F(PageNodeImplTest, CalculatePageCPUUsageForMultiplePagesInSingleProcess) {
-  MockMultiplePagesInSingleProcessGraph mock_graph(graph());
-  mock_graph.process->SetCPUUsage(40);
-  EXPECT_EQ(20, mock_graph.page->GetCPUUsage());
-  EXPECT_EQ(20, mock_graph.other_page->GetCPUUsage());
-}
-
-TEST_F(PageNodeImplTest,
-       CalculatePageCPUUsageForSinglePageWithMultipleProcesses) {
-  MockSinglePageWithMultipleProcessesGraph mock_graph(graph());
-  mock_graph.process->SetCPUUsage(40);
-  mock_graph.other_process->SetCPUUsage(30);
-  EXPECT_EQ(70, mock_graph.page->GetCPUUsage());
-}
-
-TEST_F(PageNodeImplTest,
-       CalculatePageCPUUsageForMultiplePagesWithMultipleProcesses) {
-  MockMultiplePagesWithMultipleProcessesGraph mock_graph(graph());
-  mock_graph.process->SetCPUUsage(40);
-  mock_graph.other_process->SetCPUUsage(30);
-  EXPECT_EQ(20, mock_graph.page->GetCPUUsage());
-  EXPECT_EQ(50, mock_graph.other_page->GetCPUUsage());
-}
-
 TEST_F(PageNodeImplTest, TimeSinceLastVisibilityChange) {
   MockSinglePageInSingleProcessGraph mock_graph(graph());
 

components/performance_manager/graph/process_node_impl.cc

@@ -24,10 +24,6 @@ ProcessNodeImpl::~ProcessNodeImpl() {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 }
 
-void ProcessNodeImpl::SetCPUUsage(double cpu_usage) {
-  cpu_usage_ = cpu_usage;
-}
-
 void ProcessNodeImpl::Bind(
     mojo::PendingReceiver<mojom::ProcessCoordinationUnit> receiver) {
   // A RenderProcessHost can be reused if the backing process suddenly dies, in
@@ -136,7 +132,6 @@ void ProcessNodeImpl::SetProcessImpl(base::Process process,
   // process.
   private_footprint_kb_ = 0;
   resident_set_kb_ = 0;
-  cumulative_cpu_usage_ = base::TimeDelta();
 
   process_id_ = new_pid;
   launch_time_ = launch_time;
@@ -195,16 +190,6 @@ bool ProcessNodeImpl::GetMainThreadTaskLoadIsLow() const {
   return main_thread_task_load_is_low();
 }
 
-double ProcessNodeImpl::GetCpuUsage() const {
-  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
-  return cpu_usage();
-}
-
-base::TimeDelta ProcessNodeImpl::GetCumulativeCpuUsage() const {
-  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
-  return cumulative_cpu_usage();
-}
-
 uint64_t ProcessNodeImpl::GetPrivateFootprintKb() const {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   return private_footprint_kb();

components/performance_manager/graph/process_node_impl.h

@@ -53,10 +53,6 @@ class ProcessNodeImpl
   void SetExpectedTaskQueueingDuration(base::TimeDelta duration) override;
   void SetMainThreadTaskLoadIsLow(bool main_thread_task_load_is_low) override;
 
-  // CPU usage is expressed as the average percentage of cores occupied over the
-  // last measurement interval. One core fully occupied would be 100, while two
-  // cores at 5% each would be 10.
-  void SetCPUUsage(double cpu_usage);
   void SetProcessExitStatus(int32_t exit_status);
   void SetProcess(base::Process process, base::Time launch_time);
 
@@ -65,14 +61,10 @@ class ProcessNodeImpl
     private_footprint_kb_ = private_footprint_kb;
   }
   uint64_t private_footprint_kb() const { return private_footprint_kb_; }
-  void set_cumulative_cpu_usage(base::TimeDelta cumulative_cpu_usage) {
-    cumulative_cpu_usage_ = cumulative_cpu_usage;
-  }
   uint64_t resident_set_kb() const { return resident_set_kb_; }
   void set_resident_set_kb(uint64_t resident_set_kb) {
     resident_set_kb_ = resident_set_kb;
   }
-  base::TimeDelta cumulative_cpu_usage() const { return cumulative_cpu_usage_; }
 
   const base::flat_set<FrameNodeImpl*>& frame_nodes() const;
 
@@ -106,8 +98,6 @@ class ProcessNodeImpl
 
   base::TaskPriority priority() const { return priority_.value(); }
 
-  double cpu_usage() const { return cpu_usage_; }
-
   // Add |frame_node| to this process.
   void AddFrame(FrameNodeImpl* frame_node);
   // Removes |frame_node| from the set of frames hosted by this process. Invoked
@@ -144,8 +134,6 @@ class ProcessNodeImpl
   base::flat_set<const FrameNode*> GetFrameNodes() const override;
   base::TimeDelta GetExpectedTaskQueueingDuration() const override;
   bool GetMainThreadTaskLoadIsLow() const override;
-  double GetCpuUsage() const override;
-  base::TimeDelta GetCumulativeCpuUsage() const override;
   uint64_t GetPrivateFootprintKb() const override;
   uint64_t GetResidentSetKb() const override;
   const RenderProcessHostProxy& GetRenderProcessHostProxy() const override;
@@ -157,7 +145,6 @@ class ProcessNodeImpl
 
   mojo::Receiver<mojom::ProcessCoordinationUnit> receiver_{this};
 
-  base::TimeDelta cumulative_cpu_usage_;
   uint64_t private_footprint_kb_ = 0u;
   uint64_t resident_set_kb_ = 0;
 
@@ -180,7 +167,6 @@ class ProcessNodeImpl
       bool,
       &ProcessNodeObserver::OnMainThreadTaskLoadIsLow>
       main_thread_task_load_is_low_{false};
-  double cpu_usage_ = 0;
 
   // Process priority information. This is aggregated from the priority of
   // all workers and frames in a given process.

components/performance_manager/graph/process_node_impl_unittest.cc

@@ -36,12 +36,6 @@ TEST_F(ProcessNodeImplDeathTest, SafeDowncast) {
   ASSERT_DEATH_IF_SUPPORTED(FrameNodeImpl::FromNodeBase(process.get()), "");
 }
 
-TEST_F(ProcessNodeImplTest, MeasureCPUUsage) {
-  auto process_node = CreateNode<ProcessNodeImpl>();
-  process_node->SetCPUUsage(1.0);
-  EXPECT_EQ(1.0, process_node->cpu_usage());
-}
-
 TEST_F(ProcessNodeImplTest, ProcessLifeCycle) {
   auto process_node = CreateNode<ProcessNodeImpl>();
 
@@ -68,12 +62,9 @@ TEST_F(ProcessNodeImplTest, ProcessLifeCycle) {
 
   EXPECT_EQ(0U, process_node->private_footprint_kb());
   EXPECT_EQ(0U, process_node->resident_set_kb());
-  EXPECT_EQ(base::TimeDelta(), process_node->cumulative_cpu_usage());
 
-  constexpr base::TimeDelta kCpuUsage = base::TimeDelta::FromMicroseconds(1);
   process_node->set_private_footprint_kb(10u);
   process_node->set_resident_set_kb(20u);
-  process_node->set_cumulative_cpu_usage(kCpuUsage);
 
   // Kill it again.
   // Verify that the process is cleared, but the properties stick around.
@@ -84,7 +75,6 @@ TEST_F(ProcessNodeImplTest, ProcessLifeCycle) {
   EXPECT_EQ(launch_time, process_node->launch_time());
   EXPECT_EQ(10u, process_node->private_footprint_kb());
   EXPECT_EQ(20u, process_node->resident_set_kb());
-  EXPECT_EQ(kCpuUsage, process_node->cumulative_cpu_usage());
 
   // Resurrect again and verify the launch time and measurements
   // are cleared.
@@ -94,7 +84,6 @@ TEST_F(ProcessNodeImplTest, ProcessLifeCycle) {
   EXPECT_EQ(launch2_time, process_node->launch_time());
   EXPECT_EQ(0U, process_node->private_footprint_kb());
   EXPECT_EQ(0U, process_node->resident_set_kb());
-  EXPECT_EQ(base::TimeDelta(), process_node->cumulative_cpu_usage());
 }
 
 TEST_F(ProcessNodeImplTest, GetPageNodeIfExclusive) {
@@ -257,13 +246,6 @@ TEST_F(ProcessNodeImplTest, PublicInterface) {
   EXPECT_EQ(process_node->main_thread_task_load_is_low(),
             public_process_node->GetMainThreadTaskLoadIsLow());
 
-  process_node->SetCPUUsage(0.5);
-  EXPECT_EQ(process_node->cpu_usage(), public_process_node->GetCpuUsage());
-
-  process_node->set_cumulative_cpu_usage(base::TimeDelta::FromSeconds(1));
-  EXPECT_EQ(process_node->cumulative_cpu_usage(),
-            public_process_node->GetCumulativeCpuUsage());
-
   process_node->set_private_footprint_kb(628);
   EXPECT_EQ(process_node->private_footprint_kb(),
             public_process_node->GetPrivateFootprintKb());

components/performance_manager/public/graph/process_node.h

@@ -82,14 +82,6 @@ class ProcessNode : public Node {
   // of usage). See ProcessNodeObserver::OnMainThreadTaskLoadIsLow.
   virtual bool GetMainThreadTaskLoadIsLow() const = 0;
 
-  // Returns the current renderer process CPU usage. A value of 1.0 can mean 1
-  // core at 100%, or 2 cores at 50% each, for example.
-  virtual double GetCpuUsage() const = 0;
-
-  // Returns the cumulative CPU usage of the renderer process over its entire
-  // lifetime, expressed as CPU seconds.
-  virtual base::TimeDelta GetCumulativeCpuUsage() const = 0;
-
   // Returns the most recently measured private memory footprint of the process.
   // This is roughly private, anonymous, non-discardable, resident or swapped
   // memory in kilobytes. For more details, see https://goo.gl/3kPb9S.