Ad metrics: Make AdsPLMO a V8PerFrameMemoryObserverAnySeq subclass.

We also add the base::Feature kV8PerAdFrameMemoryMonitoring in order
to experiment via Finch to find a suitable memory polling interval.

In a followup CL, we will implement the OnV8MemoryMeasurementAvailable
method and create and populate memory data histograms.

Bug: 1117176,1116087
Change-Id: Iee3ca57247c85285af9d293f2da6bfe38574f64c
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2323505
Commit-Queue: Cammie Smith Barnes <cammie@chromium.org>
Reviewed-by: Joe Mason <joenotcharles@chromium.org>
Reviewed-by: John Delaney <johnidel@chromium.org>
Cr-Commit-Position: refs/heads/master@{#798792}

chrome/browser/page_load_metrics/observers/ad_metrics/ads_page_load_metrics_observer.cc

@@ -67,6 +67,14 @@ namespace features {
 const base::Feature kRestrictedNavigationAdTagging{
     "RestrictedNavigationAdTagging", base::FEATURE_ENABLED_BY_DEFAULT};
 
+// Enables or disables per-frame memory monitoring.
+const base::Feature kV8PerAdFrameMemoryMonitoring{
+    "V8PerAdFrameMemoryMonitoring", base::FEATURE_DISABLED_BY_DEFAULT};
+
+// Minimum time between memory measurements.
+const base::FeatureParam<int> kMemoryPollInterval = {
+    &kV8PerAdFrameMemoryMonitoring, "kMemoryPollInterval", 40};
+
 }  // namespace features
 
 namespace {
@@ -209,7 +217,10 @@ AdsPageLoadMetricsObserver::AdsPageLoadMetricsObserver(
           std::make_unique<HeavyAdThresholdNoiseProvider>(
               heavy_ad_privacy_mitigations_enabled_ /* use_noise */)) {}
 
-AdsPageLoadMetricsObserver::~AdsPageLoadMetricsObserver() = default;
+AdsPageLoadMetricsObserver::~AdsPageLoadMetricsObserver() {
+  if (memory_request_)
+    memory_request_->RemoveObserver(this);
+}
 
 page_load_metrics::PageLoadMetricsObserver::ObservePolicy
 AdsPageLoadMetricsObserver::OnStart(
@@ -392,6 +403,19 @@ void AdsPageLoadMetricsObserver::UpdateAdFrameData(
       previous_data->UpdateForNavigation(ad_host, frame_navigated);
       return;
     }
+    if (base::FeatureList::IsEnabled(features::kV8PerAdFrameMemoryMonitoring) &&
+        !memory_request_) {
+      // The first ad subframe has been detected, so instantiate the
+      // memory request and add AdsPLMO as an observer. Without any ads, there
+      // would be no reason to monitor ad-frame memory usage and
+      // |memory_request_| wouldn't be needed.
+      // TODO(cammie): Add parameter to make this request in lazy mode once
+      // the API has been updated.
+      memory_request_ = std::make_unique<
+          performance_manager::v8_memory::V8PerFrameMemoryRequestAnySeq>(
+          base::TimeDelta::FromSeconds(features::kMemoryPollInterval.Get()));
+      memory_request_->AddObserver(this);
+    }
     ad_frames_data_storage_.emplace_back(
         ad_id,
         heavy_ad_threshold_noise_provider_->GetNetworkThresholdNoiseForFrame());

chrome/browser/page_load_metrics/observers/ad_metrics/ads_page_load_metrics_observer.h

@@ -11,12 +11,14 @@
 #include <memory>
 
 #include "base/macros.h"
+#include "base/metrics/field_trial_params.h"
 #include "base/scoped_observer.h"
 #include "base/time/tick_clock.h"
 #include "chrome/browser/page_load_metrics/observers/ad_metrics/frame_data.h"
 #include "chrome/browser/page_load_metrics/observers/ad_metrics/page_ad_density_tracker.h"
 #include "components/page_load_metrics/browser/page_load_metrics_observer.h"
 #include "components/page_load_metrics/common/page_load_metrics.mojom-forward.h"
+#include "components/performance_manager/public/v8_memory/v8_per_frame_memory_decorator.h"
 #include "components/subresource_filter/content/browser/subresource_filter_observer.h"
 #include "components/subresource_filter/content/browser/subresource_filter_observer_manager.h"
 #include "components/subresource_filter/core/common/load_policy.h"
@@ -25,6 +27,8 @@
 
 namespace features {
 extern const base::Feature kRestrictedNavigationAdTagging;
+extern const base::Feature kV8PerAdFrameMemoryMonitoring;
+extern const base::FeatureParam<int> kMemoryPollInterval;
 }
 
 class HeavyAdBlocklist;
@@ -33,6 +37,7 @@ class HeavyAdBlocklist;
 // relevant per-frame and whole-page byte statistics.
 class AdsPageLoadMetricsObserver
     : public page_load_metrics::PageLoadMetricsObserver,
+      public performance_manager::v8_memory::V8PerFrameMemoryObserverAnySeq,
       public subresource_filter::SubresourceFilterObserver {
  public:
   // Returns a new AdsPageLoadMetricsObserver. If the feature is disabled it
@@ -132,6 +137,14 @@ class AdsPageLoadMetricsObserver
     heavy_ad_threshold_noise_provider_ = std::move(noise_provider);
   }
 
+  // performance_manager::v8_memory::V8PerFrameMemoryObserverAnySeq
+  void OnV8MemoryMeasurementAvailable(
+      performance_manager::RenderProcessHostId render_process_host_id,
+      const performance_manager::v8_memory::V8PerFrameMemoryProcessData&
+          process_data,
+      const V8PerFrameMemoryObserverAnySeq::FrameDataMap& frame_data) override {
+  }
+
  private:
   // subresource_filter::SubresourceFilterObserver:
   void OnAdSubframeDetected(
@@ -283,6 +296,11 @@ class AdsPageLoadMetricsObserver
   // The maximum ad density measurements for the page during its lifecycle.
   PageAdDensityTracker page_ad_density_tracker_;
 
+  // Tracks per ad-frame V8 memory measurements for the page during its
+  // lifecycle. Lazily initialized when the first ad is detected.
+  std::unique_ptr<performance_manager::v8_memory::V8PerFrameMemoryRequestAnySeq>
+      memory_request_;
+
   DISALLOW_COPY_AND_ASSIGN(AdsPageLoadMetricsObserver);
 };
 

chrome/browser/page_load_metrics/observers/ad_metrics/ads_page_load_metrics_observer_browsertest.cc

@@ -129,8 +129,9 @@ class AdsPageLoadMetricsObserverBrowserTest
   }
 
   void SetUp() override {
-    std::vector<base::Feature> enabled = {subresource_filter::kAdTagging,
-                                          features::kSitePerProcess};
+    std::vector<base::Feature> enabled = {
+        subresource_filter::kAdTagging, features::kSitePerProcess,
+        features::kV8PerAdFrameMemoryMonitoring};
     std::vector<base::Feature> disabled = {};
 
     if (use_process_priority_) {