ui: Use "Compute" consistently in FrameMetrics.

To improve naming consistency, this changes instances
of "Calculate" prefixes to "Compute". It also prefixes
more methods with "Compute".

Bug: 807463
Change-Id: I9ccebc5ffbdf42e24142e21d850ea4a8e8ac0364
Reviewed-on: https://chromium-review.googlesource.com/981518
Commit-Queue: Brian Anderson <brianderson@chromium.org>
Reviewed-by: Sadrul Chowdhury <sadrul@chromium.org>
Reviewed-by: Timothy Dresser <tdresser@chromium.org>
Cr-Commit-Position: refs/heads/master@{#548621}

ui/latency/frame_metrics_test_common.cc

@@ -75,7 +75,7 @@ void TestHistogram::AddSample(uint32_t value, uint32_t weight) {
   added_samples_.push_back({value, weight});
 }
 
-PercentileResults TestHistogram::CalculatePercentiles() const {
+PercentileResults TestHistogram::ComputePercentiles() const {
   return results_;
 }
 

ui/latency/frame_metrics_test_common.h

@@ -156,7 +156,7 @@ class TestHistogram : public Histogram {
 
   // Histogram interface.
   void AddSample(uint32_t value, uint32_t weight) override;
-  PercentileResults CalculatePercentiles() const override;
+  PercentileResults ComputePercentiles() const override;
   void Reset() override{};
 
   // Test interface.

ui/latency/histograms.cc

@@ -225,7 +225,7 @@ void RatioHistogram::AddSample(uint32_t ratio, uint32_t weight) {
   total_samples_ += weight;
 }
 
-PercentileResults RatioHistogram::CalculatePercentiles() const {
+PercentileResults RatioHistogram::ComputePercentiles() const {
   RatioBoundaryIterator i;
   return PercentilesHelper(&i, buckets_.data(),
                            buckets_.data() + buckets_.size(), total_samples_);
@@ -370,7 +370,7 @@ void VSyncHistogram::AddSample(uint32_t microseconds, uint32_t weight) {
   total_samples_ += weight;
 }
 
-PercentileResults VSyncHistogram::CalculatePercentiles() const {
+PercentileResults VSyncHistogram::ComputePercentiles() const {
   VSyncBoundaryIterator i;
   return PercentilesHelper(&i, buckets_.data(),
                            buckets_.data() + buckets_.size(), total_samples_);

ui/latency/histograms.h

@@ -32,9 +32,9 @@ class Histogram {
   // Increases the bucket that contains |value| by |weight|.
   virtual void AddSample(uint32_t value, uint32_t weight) = 0;
 
-  // Calculates and returns the approximate percentiles based on the
+  // Computes and returns the approximate percentiles based on the
   // histogram distribution.
-  virtual PercentileResults CalculatePercentiles() const = 0;
+  virtual PercentileResults ComputePercentiles() const = 0;
 
   // Resets all buckets in the histogram to 0.
   // Higher level logic may periodically reset the the counts after it
@@ -52,7 +52,7 @@ class RatioHistogram : public Histogram {
   RatioHistogram();
   ~RatioHistogram() override;
   void AddSample(uint32_t ratio, uint32_t weight) override;
-  PercentileResults CalculatePercentiles() const override;
+  PercentileResults ComputePercentiles() const override;
   void Reset() override;
 
  private:
@@ -72,7 +72,7 @@ class VSyncHistogram : public Histogram {
   VSyncHistogram();
   ~VSyncHistogram() override;
   void AddSample(uint32_t microseconds, uint32_t weight) override;
-  PercentileResults CalculatePercentiles() const override;
+  PercentileResults ComputePercentiles() const override;
   void Reset() override;
 
  private:

ui/latency/histograms_perftest.cc

@@ -39,7 +39,7 @@ class RatioHistogramBaseline : public Histogram {
     sample_vector_.Accumulate(microseconds, weight);
   }
 
-  PercentileResults CalculatePercentiles() const override {
+  PercentileResults ComputePercentiles() const override {
     return PercentileResults();
   }
   void Reset() override {}
@@ -157,7 +157,7 @@ class VSyncHistogramBaseline : public Histogram {
     sample_vector_.Accumulate(microseconds, weight);
   }
 
-  PercentileResults CalculatePercentiles() const override {
+  PercentileResults ComputePercentiles() const override {
     return PercentileResults();
   }
   void Reset() override {}

ui/latency/histograms_unittest.cc

@@ -55,7 +55,7 @@ void BoundaryTestCommon(const ReferenceBoundaryT& reference_boundaries,
     uint32_t stride = std::max<uint32_t>(1u, (bucket_end - bucket_start) / 8);
     for (uint64_t value = bucket_start; value < bucket_end; value += stride) {
       histogram->AddSample(value, 1);
-      percentiles = histogram->CalculatePercentiles();
+      percentiles = histogram->ComputePercentiles();
       histogram->Reset();
       EXPECT_LE(bucket_start, percentiles.values[0]);
       EXPECT_GT(bucket_end, percentiles.values[0]);
@@ -63,7 +63,7 @@ void BoundaryTestCommon(const ReferenceBoundaryT& reference_boundaries,
 
     // Verify the value just before the next bucket doesn't affect percentile.
     histogram->AddSample(bucket_end - 1, 1);
-    percentiles = histogram->CalculatePercentiles();
+    percentiles = histogram->ComputePercentiles();
     histogram->Reset();
     EXPECT_LE(bucket_start, percentiles.values[0]);
     EXPECT_GT(bucket_end, percentiles.values[0]);
@@ -112,7 +112,7 @@ void PercentilesTestCommon(const ReferenceBoundaryT& reference_boundaries,
                            samples_added_outside - samples_added_left);
     }
 
-    percentiles = histogram->CalculatePercentiles();
+    percentiles = histogram->ComputePercentiles();
     histogram->Reset();
 
     double index = (samples_added_inside + samples_added_outside) * percentile -

ui/latency/stream_analyzer.cc

@@ -136,7 +136,7 @@ std::vector<ThresholdResult> StreamAnalyzer::ComputeThresholds() const {
 
 PercentileResults StreamAnalyzer::ComputePercentiles() const {
   PercentileResults result;
-  result = histogram_->CalculatePercentiles();
+  result = histogram_->ComputePercentiles();
   for (size_t i = 0; i < PercentileResults::kCount; i++) {
     result.values[i] = client_->TransformResult(result.values[i]);
   }

ui/latency/stream_analyzer_unittest.cc

@@ -64,10 +64,10 @@ TEST_F(StreamAnalyzerTest, AllResultsTheSame) {
                                      expected_value, weight);
 
         // Verify values are forwarded to the WindowedAnalyzer.
-        EXPECT_EQ(expected_value, analyzer_->window().WorstMean().value);
-        EXPECT_EQ(expected_value, analyzer_->window().WorstRMS().value);
-        EXPECT_NEAR_SMR(expected_value, analyzer_->window().WorstSMR().value,
-                        weight);
+        EXPECT_EQ(expected_value, analyzer_->window().ComputeWorstMean().value);
+        EXPECT_EQ(expected_value, analyzer_->window().ComputeWorstRMS().value);
+        EXPECT_NEAR_SMR(expected_value,
+                        analyzer_->window().ComputeWorstSMR().value, weight);
       }
     }
   }
@@ -90,10 +90,10 @@ TEST_F(StreamAnalyzerTest, AllResultsTheSame) {
                                    expected_value, weight);
 
       // Verify values are forwarded to the WindowedAnalyzer.
-      EXPECT_EQ(expected_value, analyzer_->window().WorstMean().value);
-      EXPECT_EQ(expected_value, analyzer_->window().WorstRMS().value);
-      EXPECT_NEAR_SMR(expected_value, analyzer_->window().WorstSMR().value,
-                      weight);
+      EXPECT_EQ(expected_value, analyzer_->window().ComputeWorstMean().value);
+      EXPECT_EQ(expected_value, analyzer_->window().ComputeWorstRMS().value);
+      EXPECT_NEAR_SMR(expected_value,
+                      analyzer_->window().ComputeWorstSMR().value, weight);
     }
   }
 }

ui/latency/windowed_analyzer.cc

@@ -88,7 +88,7 @@ void WindowedAnalyzer::AddSample(uint32_t value,
   }
 }
 
-FrameRegionResult WindowedAnalyzer::WorstMean() const {
+FrameRegionResult WindowedAnalyzer::ComputeWorstMean() const {
   FrameRegionResult result;
   if (results_) {
     result = results_->mean;
@@ -99,7 +99,7 @@ FrameRegionResult WindowedAnalyzer::WorstMean() const {
   return result;
 }
 
-FrameRegionResult WindowedAnalyzer::WorstRMS() const {
+FrameRegionResult WindowedAnalyzer::ComputeWorstRMS() const {
   FrameRegionResult result;
   if (results_) {
     result = results_->square;
@@ -110,7 +110,7 @@ FrameRegionResult WindowedAnalyzer::WorstRMS() const {
   return result;
 }
 
-FrameRegionResult WindowedAnalyzer::WorstSMR() const {
+FrameRegionResult WindowedAnalyzer::ComputeWorstSMR() const {
   FrameRegionResult result;
   if (results_) {
     result = results_->root;
@@ -126,17 +126,17 @@ void WindowedAnalyzer::AsValueInto(
     base::trace_event::TracedValue* state) const {
   FrameRegionResult region;
 
-  region = WorstMean();
+  region = ComputeWorstMean();
   state->BeginDictionary("worst_mean");
   region.AsValueInto(state);
   state->EndDictionary();
 
-  region = WorstSMR();
+  region = ComputeWorstSMR();
   state->BeginDictionary("worst_smr");
   region.AsValueInto(state);
   state->EndDictionary();
 
-  region = WorstRMS();
+  region = ComputeWorstRMS();
   state->BeginDictionary("worst_rms");
   region.AsValueInto(state);
   state->EndDictionary();

ui/latency/windowed_analyzer.h

@@ -99,9 +99,9 @@ class WindowedAnalyzer {
                  const Accumulator96b& weighted_square);
 
   // Returns the worst regions encountered so far.
-  FrameRegionResult WorstMean() const;
-  FrameRegionResult WorstRMS() const;
-  FrameRegionResult WorstSMR() const;
+  FrameRegionResult ComputeWorstMean() const;
+  FrameRegionResult ComputeWorstRMS() const;
+  FrameRegionResult ComputeWorstSMR() const;
 
   void AsValueInto(base::trace_event::TracedValue* state) const;
 

ui/latency/windowed_analyzer_unittest.cc

@@ -33,11 +33,12 @@ TEST(FrameMetricsWindowedAnalyzerTest, AllResultsTheSame) {
         AddSamplesHelper(&analyzer, value, weight, samples);
         uint64_t expected_value =
             value * TestWindowedAnalyzerClient::result_scale;
-        EXPECT_EQ(analyzer.WorstMean().value, expected_value)
+        EXPECT_EQ(analyzer.ComputeWorstMean().value, expected_value)
             << value << " x " << weight;
-        EXPECT_EQ(analyzer.WorstRMS().value, expected_value)
+        EXPECT_EQ(analyzer.ComputeWorstRMS().value, expected_value)
             << value << " x " << weight;
-        EXPECT_NEAR_SMR(analyzer.WorstSMR().value, expected_value, weight)
+        EXPECT_NEAR_SMR(analyzer.ComputeWorstSMR().value, expected_value,
+                        weight)
             << value << " x " << weight;
       }
     }
@@ -54,11 +55,11 @@ TEST(FrameMetricsWindowedAnalyzerTest, AllResultsTheSame) {
       uint64_t expected_value =
           value * TestWindowedAnalyzerClient::result_scale;
       // Makes sure our precision is good enough.
-      EXPECT_EQ(analyzer.WorstMean().value, expected_value)
+      EXPECT_EQ(analyzer.ComputeWorstMean().value, expected_value)
           << value << " x " << weight;
-      EXPECT_EQ(analyzer.WorstRMS().value, expected_value)
+      EXPECT_EQ(analyzer.ComputeWorstRMS().value, expected_value)
           << value << " x " << weight;
-      EXPECT_NEAR_SMR(analyzer.WorstSMR().value, expected_value, weight)
+      EXPECT_NEAR_SMR(analyzer.ComputeWorstSMR().value, expected_value, weight)
           << value << " x " << weight;
     }
   }
@@ -118,17 +119,17 @@ TEST(FrameMetricsWindowedAnalyzerTest, AllResultsDifferent) {
   AddPatternHelper(&shared_client, &analyzer, pattern_max_rms, kSampleWeight);
   AddPatternHelper(&shared_client, &analyzer, pattern_clear, kSampleWeight);
 
-  FrameRegionResult worst_mean = analyzer.WorstMean();
+  FrameRegionResult worst_mean = analyzer.ComputeWorstMean();
   EXPECT_DOUBLE_EQ(expected_worst_mean, worst_mean.value);
   EXPECT_EQ(worst_mean_client.window_begin, worst_mean.window_begin);
   EXPECT_EQ(worst_mean_client.window_end, worst_mean.window_end);
 
-  FrameRegionResult worst_smr = analyzer.WorstSMR();
+  FrameRegionResult worst_smr = analyzer.ComputeWorstSMR();
   EXPECT_NEAR_SMR(expected_worst_smr, worst_smr.value, kSampleWeight);
   EXPECT_EQ(worst_smr_client.window_begin, worst_smr.window_begin);
   EXPECT_EQ(worst_smr_client.window_end, worst_smr.window_end);
 
-  FrameRegionResult worst_rms = analyzer.WorstRMS();
+  FrameRegionResult worst_rms = analyzer.ComputeWorstRMS();
   EXPECT_DOUBLE_EQ(expected_worst_rms, worst_rms.value);
   EXPECT_EQ(worst_rms_client.window_begin, worst_rms.window_begin);
   EXPECT_EQ(worst_rms_client.window_end, worst_rms.window_end);
@@ -152,17 +153,17 @@ TEST(FrameMetricsWindowedAnalyzerTest, SmallSampleSize) {
   AddPatternHelper(&shared_client, &analyzer, pattern_short, kSampleWeight);
   SharedWindowedAnalyzerClient short_client(shared_client);
 
-  FrameRegionResult worst_mean = analyzer.WorstMean();
+  FrameRegionResult worst_mean = analyzer.ComputeWorstMean();
   EXPECT_DOUBLE_EQ(expected_initial_value, worst_mean.value);
   EXPECT_EQ(short_client.window_begin, worst_mean.window_begin);
   EXPECT_EQ(short_client.window_end, worst_mean.window_end);
 
-  FrameRegionResult worst_smr = analyzer.WorstSMR();
+  FrameRegionResult worst_smr = analyzer.ComputeWorstSMR();
   EXPECT_NEAR_SMR(expected_initial_value, worst_smr.value, kSampleWeight);
   EXPECT_EQ(short_client.window_begin, worst_smr.window_begin);
   EXPECT_EQ(short_client.window_end, worst_smr.window_end);
 
-  FrameRegionResult worst_rms = analyzer.WorstRMS();
+  FrameRegionResult worst_rms = analyzer.ComputeWorstRMS();
   EXPECT_DOUBLE_EQ(expected_initial_value, worst_rms.value);
   EXPECT_EQ(short_client.window_begin, worst_rms.window_begin);
   EXPECT_EQ(short_client.window_end, worst_rms.window_end);
@@ -189,17 +190,17 @@ TEST(FrameMetricsWindowedAnalyzerTest, BadFirstSamples) {
   AddPatternHelper(&shared_client, &analyzer, pattern_short, kSampleWeight);
   SharedWindowedAnalyzerClient short_client(shared_client);
 
-  worst_mean = analyzer.WorstMean();
+  worst_mean = analyzer.ComputeWorstMean();
   EXPECT_DOUBLE_EQ(expected_initial_value, worst_mean.value);
   EXPECT_EQ(short_client.window_begin, worst_mean.window_begin);
   EXPECT_EQ(short_client.window_end, worst_mean.window_end);
 
-  worst_smr = analyzer.WorstSMR();
+  worst_smr = analyzer.ComputeWorstSMR();
   EXPECT_NEAR_SMR(expected_initial_value, worst_smr.value, kSampleWeight);
   EXPECT_EQ(short_client.window_begin, worst_smr.window_begin);
   EXPECT_EQ(short_client.window_end, worst_smr.window_end);
 
-  worst_rms = analyzer.WorstRMS();
+  worst_rms = analyzer.ComputeWorstRMS();
   EXPECT_DOUBLE_EQ(expected_initial_value, worst_rms.value);
   EXPECT_EQ(short_client.window_begin, worst_rms.window_begin);
   EXPECT_EQ(short_client.window_end, worst_rms.window_end);
@@ -215,17 +216,17 @@ TEST(FrameMetricsWindowedAnalyzerTest, BadFirstSamples) {
   AddPatternHelper(&shared_client, &analyzer, pattern_long, kSampleWeight);
   SharedWindowedAnalyzerClient long_client(shared_client);
 
-  worst_mean = analyzer.WorstMean();
+  worst_mean = analyzer.ComputeWorstMean();
   EXPECT_DOUBLE_EQ(expected_final_value, worst_mean.value);
   EXPECT_EQ(long_client.window_begin, worst_mean.window_begin);
   EXPECT_EQ(long_client.window_end, worst_mean.window_end);
 
-  worst_smr = analyzer.WorstSMR();
+  worst_smr = analyzer.ComputeWorstSMR();
   EXPECT_NEAR_SMR(expected_final_value, worst_smr.value, kSampleWeight);
   EXPECT_EQ(long_client.window_begin, worst_smr.window_begin);
   EXPECT_EQ(long_client.window_end, worst_smr.window_end);
 
-  worst_rms = analyzer.WorstRMS();
+  worst_rms = analyzer.ComputeWorstRMS();
   EXPECT_DOUBLE_EQ(expected_final_value, worst_rms.value);
   EXPECT_EQ(long_client.window_begin, worst_rms.window_begin);
   EXPECT_EQ(long_client.window_end, worst_rms.window_end);
@@ -250,17 +251,17 @@ TEST(FrameMetricsWindowedAnalyzerTest, ResetWorstValues) {
   AddPatternHelper(&shared_client, &analyzer, pattern1, kSampleWeight);
   SharedWindowedAnalyzerClient initial_client(shared_client);
 
-  worst_mean = analyzer.WorstMean();
+  worst_mean = analyzer.ComputeWorstMean();
   EXPECT_DOUBLE_EQ(expected_initial_value, worst_mean.value);
   EXPECT_EQ(initial_client.window_begin, worst_mean.window_begin);
   EXPECT_EQ(initial_client.window_end, worst_mean.window_end);
 
-  worst_smr = analyzer.WorstSMR();
+  worst_smr = analyzer.ComputeWorstSMR();
   EXPECT_NEAR_SMR(expected_initial_value, worst_smr.value, kSampleWeight);
   EXPECT_EQ(initial_client.window_begin, worst_smr.window_begin);
   EXPECT_EQ(initial_client.window_end, worst_smr.window_end);
 
-  worst_rms = analyzer.WorstRMS();
+  worst_rms = analyzer.ComputeWorstRMS();
   EXPECT_DOUBLE_EQ(expected_initial_value, worst_rms.value);
   EXPECT_EQ(initial_client.window_begin, worst_rms.window_begin);
   EXPECT_EQ(initial_client.window_end, worst_rms.window_end);
@@ -270,17 +271,17 @@ TEST(FrameMetricsWindowedAnalyzerTest, ResetWorstValues) {
   const std::vector<uint32_t> pattern2 = {4, 4, 4, 4, 4, 4};
   AddPatternHelper(&shared_client, &analyzer, pattern2, kSampleWeight);
 
-  worst_mean = analyzer.WorstMean();
+  worst_mean = analyzer.ComputeWorstMean();
   EXPECT_DOUBLE_EQ(expected_initial_value, worst_mean.value);
   EXPECT_EQ(initial_client.window_begin, worst_mean.window_begin);
   EXPECT_EQ(initial_client.window_end, worst_mean.window_end);
 
-  worst_smr = analyzer.WorstSMR();
+  worst_smr = analyzer.ComputeWorstSMR();
   EXPECT_NEAR_SMR(expected_initial_value, worst_smr.value, kSampleWeight);
   EXPECT_EQ(initial_client.window_begin, worst_smr.window_begin);
   EXPECT_EQ(initial_client.window_end, worst_smr.window_end);
 
-  worst_rms = analyzer.WorstRMS();
+  worst_rms = analyzer.ComputeWorstRMS();
   EXPECT_DOUBLE_EQ(expected_initial_value, worst_rms.value);
   EXPECT_EQ(initial_client.window_begin, worst_rms.window_begin);
   EXPECT_EQ(initial_client.window_end, worst_rms.window_end);
@@ -301,17 +302,17 @@ TEST(FrameMetricsWindowedAnalyzerTest, ResetWorstValues) {
   const std::vector<uint32_t> pattern4 = {1, 1, 1, 1, 1, 1};
   AddPatternHelper(&shared_client, &analyzer, pattern4, kSampleWeight);
 
-  worst_mean = analyzer.WorstMean();
+  worst_mean = analyzer.ComputeWorstMean();
   EXPECT_DOUBLE_EQ(expected_final_value, worst_mean.value);
   EXPECT_EQ(final_client.window_begin, worst_mean.window_begin);
   EXPECT_EQ(final_client.window_end, worst_mean.window_end);
 
-  worst_smr = analyzer.WorstSMR();
+  worst_smr = analyzer.ComputeWorstSMR();
   EXPECT_NEAR_SMR(expected_final_value, worst_smr.value, kSampleWeight);
   EXPECT_EQ(final_client.window_begin, worst_smr.window_begin);
   EXPECT_EQ(final_client.window_end, worst_smr.window_end);
 
-  worst_rms = analyzer.WorstRMS();
+  worst_rms = analyzer.ComputeWorstRMS();
   EXPECT_DOUBLE_EQ(expected_final_value, worst_rms.value);
   EXPECT_EQ(final_client.window_begin, worst_rms.window_begin);
   EXPECT_EQ(final_client.window_end, worst_rms.window_end);