Use FrameIsAd to decide whether to isolate a frame in TopDocumentIsolation mode.

chrome/browser/page_load_metrics/observers/ads_page_load_metrics_observer_unittest.cc

 // Copyright 2017 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/page_load_metrics/observers/ads_page_load_metrics_observer.h"
 
 #include <string>
+#include <utility>
+#include <vector>
 
 #include "base/macros.h"
 #include "base/strings/stringprintf.h"
 #include "base/test/histogram_tester.h"
+#include "chrome/browser/page_load_metrics/ads_detection.h"
 #include "chrome/browser/page_load_metrics/metrics_web_contents_observer.h"
 #include "chrome/browser/page_load_metrics/observers/page_load_metrics_observer_test_harness.h"
 #include "chrome/browser/page_load_metrics/page_load_metrics_observer.h"
 #include "chrome/browser/page_load_metrics/page_load_tracker.h"
 #include "components/subresource_filter/content/browser/subresource_filter_observer_manager.h"
 #include "components/subresource_filter/core/common/load_policy.h"
 #include "content/public/browser/global_request_id.h"
 #include "content/public/browser/navigation_handle.h"
 #include "content/public/browser/navigation_throttle.h"
 #include "content/public/browser/render_frame_host.h"
@@ skipping 10 matching lines @@
 
 namespace {
 
 struct ExpectedFrameBytes {
   ExpectedFrameBytes(size_t cached_kb, size_t uncached_kb)
       : cached_kb(cached_kb), uncached_kb(uncached_kb) {}
   size_t cached_kb;
   size_t uncached_kb;
 };
 
-enum class AdType { GOOGLE = 0, SUBRESOURCE_FILTER = 1, ALL = 2 };
 enum class ResourceCached { NOT_CACHED, CACHED };
 enum class FrameType { AD = 0, NON_AD };
 
 const char kAdUrl[] = "https://tpc.googlesyndication.com/safeframe/1";
 const char kSubresourceFilterWouldDisallowAdUrl[] = "https://ad.example.com/";
 const char kSubresourceFilterDisallowAdUrl[] =
     "https://ad.example.com/disallow";
 const char kNonAdUrl[] = "https://foo.com/";
 const char kNonAdUrl2[] = "https://bar.com/";
 
@@ skipping 62 matching lines @@
     throttle_->Cancel();
   }
 
  private:
   DelayWillProcessResponseThrottle* throttle_ = nullptr;
   content::GlobalRequestID global_request_id_;
 
   DISALLOW_COPY_AND_ASSIGN(DelayWillProcessResponseObserver);
 };
 
-std::string AdTypeToString(AdType ad_type) {
+std::string AdTypeToString(page_load_metrics::AdType ad_type) {
   switch (ad_type) {
-    case AdType::GOOGLE:
+    case page_load_metrics::AD_TYPE_GOOGLE:
       return "Google";
-    case AdType::SUBRESOURCE_FILTER:
+    case page_load_metrics::AD_TYPE_SUBRESOURCE_FILTER:
       return "SubresourceFilter";
-    case AdType::ALL:
+    case page_load_metrics::AD_TYPE_ALL:
       return "All";
   }
   ADD_FAILURE();
   return "";
 }
 
-std::string TypedHistogram(const std::string& suffix, AdType ad_type) {
+std::string TypedHistogram(const std::string& suffix,
+                           page_load_metrics::AdType ad_type) {
   return base::StringPrintf("PageLoad.Clients.Ads.%s.%s",
                             AdTypeToString(ad_type).c_str(), suffix.c_str());
 }
 
 // Verifies that the histograms match what is expected given |google_ad_frames|
 // ad frame byte counts and non-ad counts (|other_cached_kb| and
 // |other_uncached_kb|).
 void TestHistograms(const base::HistogramTester& histograms,
                     const std::vector<ExpectedFrameBytes>& google_ad_frames,
                     size_t non_ad_cached_kb,
                     size_t non_ad_uncached_kb,
-                    AdType ad_type) {
+                    page_load_metrics::AdType ad_type) {
   size_t total_ad_cached_kb = 0;
   size_t total_ad_uncached_kb = 0;
   size_t total_ad_kb = 0;
   size_t ad_frame_count = 0;
 
   std::map<size_t, int> frames_with_total_byte_count;
   std::map<size_t, int> frames_with_network_byte_count;
   std::map<size_t, int> frames_with_percent_network_count;
 
   // Perform some initial calculations on the number of bytes, of each type,
@@ skipping 182 matching lines @@
       CreateAndNavigateSubFrame(kNonAdUrl, kNonAdName, main_frame);
   LoadResource(main_frame, ResourceCached::NOT_CACHED, 10);
   LoadResource(frame1, ResourceCached::NOT_CACHED, 10);
   LoadResource(frame2, ResourceCached::NOT_CACHED, 10);
 
   // Navigate again to trigger histograms.
   NavigateFrame(kNonAdUrl, main_frame);
 
   TestHistograms(histogram_tester(), std::vector<ExpectedFrameBytes>(),
                  0 /* non_ad_cached_kb */, 30 /* non_ad_uncached_kb */,
-                 AdType::GOOGLE);
+                 page_load_metrics::AD_TYPE_GOOGLE);
 
   // Verify that other UMA wasn't written.
   histogram_tester().ExpectTotalCount(
       "PageLoad.Clients.Ads.Google.Bytes.AdFrames.Aggregate.Total", 0);
 }
 
 TEST_F(AdsPageLoadMetricsObserverTest, ResourceBeforeAdFrameCommits) {
   RenderFrameHost* main_frame = NavigateMainFrame(kNonAdUrl);
 
   LoadResource(main_frame, ResourceCached::NOT_CACHED, 10);
 
   // Assume that the next frame's id will be the main frame + 1 and load a
   // resource for that frame. Make sure it gets counted.
   page_load_metrics::ExtraRequestCompleteInfo request(
       GURL(kNonAdUrl), net::HostPortPair(),
       main_frame->GetFrameTreeNodeId() + 1, false /* cached */,
       10 * 1024 /* size */, 0 /* original_network_content_length */,
       nullptr
       /* data_reduction_proxy_data */,
       content::RESOURCE_TYPE_SUB_FRAME, 0);
   SimulateLoadedResource(request);
 
   CreateAndNavigateSubFrame(kNonAdUrl, kAdName, main_frame);
 
   // Navigate again to trigger histograms.
   NavigateFrame(kNonAdUrl, main_frame);
 
   TestHistograms(histogram_tester(), {{0, 10}}, 0 /* non_ad_cached_kb */,
-                 10 /*non_ad_uncached_kb*/, AdType::GOOGLE);
+                 10 /*non_ad_uncached_kb*/, page_load_metrics::AD_TYPE_GOOGLE);
 }
 
 TEST_F(AdsPageLoadMetricsObserverTest, AllAdTypesInPage) {
   RenderFrameHost* main_frame = NavigateMainFrame(kNonAdUrl);
   RenderFrameHost* non_ad_frame =
       CreateAndNavigateSubFrame(kNonAdUrl, kNonAdName, main_frame);
 
   // Create 5 ad frames with the 5th nested inside the 4th. Verify that the
   // nested ad frame doesn't get counted separately (but that its bytes are
   // still counted). Also verify that the various ad signals (urls and names)
@@ skipping 28 matching lines @@
   LoadResource(srf_frame1, ResourceCached::NOT_CACHED, 10);
   LoadResource(srf_frame2, ResourceCached::NOT_CACHED, 10);
   LoadResource(nested_srf_frame3, ResourceCached::CACHED, 10);
   LoadResource(disallowed_srf_frame, ResourceCached::CACHED, 10);
 
   // Navigate again to trigger histograms.
   NavigateFrame(kNonAdUrl, main_frame);
 
   TestHistograms(histogram_tester(), {{10, 0}, {0, 10}},
                  30 /* non_ad_cached_kb */, 30 /* non_ad_uncached_kb */,
-                 AdType::GOOGLE);
+                 page_load_metrics::AD_TYPE_GOOGLE);
   TestHistograms(histogram_tester(), {{0, 10}, {10, 10}},
                  30 /* non_ad_cached_kb */, 20 /* non_ad_uncached_kb */,
-                 AdType::SUBRESOURCE_FILTER);
+                 page_load_metrics::AD_TYPE_SUBRESOURCE_FILTER);
   TestHistograms(histogram_tester(), {{10, 0}, {0, 10}, {0, 10}, {10, 10}},
                  20 /* non_ad_cached_kb */, 10 /* non_ad_uncached_kb */,
-                 AdType::ALL);
+                 page_load_metrics::AD_TYPE_ALL);
   histogram_tester().ExpectBucketCount(
       "PageLoad.Clients.Ads.All.ParentExistsForSubFrame", 0, 0);
   histogram_tester().ExpectTotalCount(
       "PageLoad.Clients.Ads.All.ResourceTypeWhenNoFrameFound", 0);
 }
 
 TEST_F(AdsPageLoadMetricsObserverTest, PageLoadSubFrameRenavigationMetrics) {
   RenderFrameHost* main_frame = NavigateMainFrame(kNonAdUrl);
 
   // Test behavior of an ad frame. Once a frame is considered an ad, it's
@@ skipping 42 matching lines @@
   // Navigate the ad frame again.
   ad_frame = NavigateFrame(kNonAdUrl, ad_frame);
 
   // In total, 30KB for entire page and 20 in one ad frame.
   LoadResource(ad_frame, ResourceCached::NOT_CACHED, 10);
 
   // Navigate again to trigger histograms.
   NavigateFrame(kNonAdUrl, main_frame);
 
   TestHistograms(histogram_tester(), {{0, 20}}, 0 /* non_ad_cached_kb */,
-                 10 /* non_ad_uncached_kb */, AdType::GOOGLE);
+                 10 /* non_ad_uncached_kb */,
+                 page_load_metrics::AD_TYPE_GOOGLE);
   histogram_tester().ExpectBucketCount(
       "PageLoad.Clients.Ads.All.ParentExistsForSubFrame", 0, 0);
   histogram_tester().ExpectTotalCount(
       "PageLoad.Clients.Ads.All.ResourceTypeWhenNoFrameFound", 0);
 }
 
 TEST_F(AdsPageLoadMetricsObserverTest, PageWithNonAdFrameThatRenavigatesToAd) {
   // Main frame.
   RenderFrameHost* main_frame = NavigateMainFrame(kNonAdUrl);
 
@@ skipping 15 matching lines @@
 
   // In total, 40KB was loaded for the entire page and 20KB from ad
   // frames (the original child ad frame and the renavigated frame which
   // turned into an ad).
 
   // Navigate again to trigger histograms.
   NavigateFrame(kNonAdUrl, main_frame);
 
   TestHistograms(histogram_tester(), {{0, 10}, {0, 10}},
                  0 /* non_ad_cached_kb */, 20 /* non_ad_uncached_kb */,
-                 AdType::GOOGLE);
+                 page_load_metrics::AD_TYPE_GOOGLE);
   histogram_tester().ExpectBucketCount(
       "PageLoad.Clients.Ads.All.ParentExistsForSubFrame", 0, 0);
   histogram_tester().ExpectTotalCount(
       "PageLoad.Clients.Ads.All.ResourceTypeWhenNoFrameFound", 0);
 }
 
 TEST_F(AdsPageLoadMetricsObserverTest, CountAbortedNavigation) {
   // If the first navigation in a frame is aborted, keep track of its bytes.
   RenderFrameHost* main_frame = NavigateMainFrame(kNonAdUrl);
   LoadResource(main_frame, ResourceCached::NOT_CACHED, 10);
@@ skipping 10 matching lines @@
   // Load resources for the aborted frame (e.g., simulate the navigation
   // aborting due to a doc.write during provisional navigation). They should
   // be counted.
   LoadResource(subframe_ad, ResourceCached::NOT_CACHED, 10);
   LoadResource(subframe_ad, ResourceCached::NOT_CACHED, 10);
 
   // Navigate again to trigger histograms.
   NavigateFrame(kNonAdUrl, main_frame);
 
   TestHistograms(histogram_tester(), {{0, 20}}, 0 /* non_ad_cached_kb */,
-                 10 /* non_ad_uncached_kb */, AdType::GOOGLE);
+                 10 /* non_ad_uncached_kb */,
+                 page_load_metrics::AD_TYPE_GOOGLE);
 }
 
 TEST_F(AdsPageLoadMetricsObserverTest, CountAbortedSecondNavigationForFrame) {
   RenderFrameHost* main_frame = NavigateMainFrame(kNonAdUrl);
   LoadResource(main_frame, ResourceCached::NOT_CACHED, 10);
 
   // Sub frame that is not an ad.
   RenderFrameHost* sub_frame =
       CreateAndNavigateSubFrame(kNonAdUrl, kNonAdName, main_frame);
   LoadResource(sub_frame, ResourceCached::NOT_CACHED, 10);
 
   // Now navigate (and abort) the subframe to an ad.
   auto navigation_simulator =
       NavigationSimulator::CreateRendererInitiated(GURL(kAdUrl), sub_frame);
   // The sub-frame renavigates before it commits.
   navigation_simulator->Start();
   navigation_simulator->Fail(net::ERR_ABORTED);
 
   // Load resources for the aborted frame (e.g., simulate the navigation
   // aborting due to a doc.write during provisional navigation). Since the
   // frame attempted to load an ad, the frame is tagged forever as an ad.
   LoadResource(sub_frame, ResourceCached::NOT_CACHED, 10);
   LoadResource(sub_frame, ResourceCached::NOT_CACHED, 10);
 
   // Navigate again to trigger histograms.
   NavigateFrame(kNonAdUrl, main_frame);
 
   TestHistograms(histogram_tester(), {{0, 20}}, 0 /* non_ad_cached_kb */,
-                 20 /* non_ad_uncached_kb */, AdType::GOOGLE);
+                 20 /* non_ad_uncached_kb */,
+                 page_load_metrics::AD_TYPE_GOOGLE);
 }
 
 TEST_F(AdsPageLoadMetricsObserverTest, TwoResourceLoadsBeforeCommit) {
   // Main frame.
   RenderFrameHost* main_frame = NavigateMainFrame(kNonAdUrl);
   LoadResource(main_frame, ResourceCached::NOT_CACHED, 10);
 
   // Now open a subframe and have its resource load before notification of
   // navigation finishing.
   page_load_metrics::ExtraRequestCompleteInfo request(
@@ skipping 14 matching lines @@
 
   // Renavigate the subframe to a successful commit. But again, the resource
   // loads before the observer sees the finished navigation.
   SimulateLoadedResource(request);
   NavigateFrame(kNonAdUrl, subframe_ad);
 
   // Navigate again to trigger histograms.
   NavigateFrame(kNonAdUrl, main_frame);
 
   TestHistograms(histogram_tester(), {{0, 20}}, 0 /* non_ad_cached_kb */,
-                 10 /* non_ad_uncached_kb */, AdType::GOOGLE);
+                 10 /* non_ad_uncached_kb */,
+                 page_load_metrics::AD_TYPE_GOOGLE);
   histogram_tester().ExpectBucketCount(
       "PageLoad.Clients.Ads.All.ParentExistsForSubFrame", 0, 0);
   histogram_tester().ExpectUniqueSample(
       "PageLoad.Clients.Ads.All.ResourceTypeWhenNoFrameFound",
       content::RESOURCE_TYPE_SUB_FRAME, 1);
 }
 
 // This tests an issue that is believed to be the cause of
 // https://crbug.com/721369. The issue is that a frame from a previous
 // navigation might commit during a new navigation, and the ads metrics won't
@@ skipping 88 matching lines @@
 
   // Force navigation to a new page to make sure OnComplete() runs for the
   // previous failed navigation.
   NavigateToUntrackedUrl();
 
   // There shouldn't be any histograms for an aborted main frame.
   EXPECT_EQ(0u, histogram_tester()
                     .GetTotalCountsForPrefix("PageLoad.Clients.Ads.Google.")
                     .size());
 }