[subresource_filter] Refactor activation suppression

components/subresource_filter/content/browser/content_subresource_filter_throttle_manager_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 "components/subresource_filter/content/browser/content_subresource_filter_throttle_manager.h"
 
 #include <memory>
 #include <utility>
 
 #include "base/logging.h"
@@ skipping 217 matching lines @@
     }
     navigation_simulator_.reset();
   }
 
   void NavigateAndCommitMainFrame(const GURL& url) {
     CreateTestNavigation(url, main_rfh());
     SimulateStartAndExpectResult(content::NavigationThrottle::PROCEED);
     SimulateCommitAndExpectResult(content::NavigationThrottle::PROCEED);
   }
 
-  void SuppressActivationForUrl(const GURL& url) {
-    urls_to_suppress_activation_.insert(url);
-  }
-
   bool ManagerHasRulesetHandle() {
     return throttle_manager_->ruleset_handle_for_testing();
   }
 
   int disallowed_notification_count() { return disallowed_notification_count_; }
 
-  int attempted_frame_activations() { return attempted_frame_activations_; }
-
  protected:
   // content::WebContentsObserver
   void DidStartNavigation(
       content::NavigationHandle* navigation_handle) override {
     if (navigation_handle->IsSameDocument())
       return;
 
     // Inject the proper throttles at this time.
     std::vector<std::unique_ptr<content::NavigationThrottle>> throttles;
     PageActivationNotificationTiming state =
         ::testing::UnitTest::GetInstance()->current_test_info()->value_param()
             ? GetParam()
             : WILL_PROCESS_RESPONSE;
     throttles.push_back(base::MakeUnique<MockPageStateActivationThrottle>(
         navigation_handle, state, throttle_manager_.get()));
     throttle_manager_->MaybeAppendNavigationThrottles(navigation_handle,
                                                       &throttles);
     for (auto& it : throttles) {
       navigation_handle->RegisterThrottleForTesting(std::move(it));
     }
   }
 
   // ContentSubresourceFilterThrottleManager::Delegate:
   void OnFirstSubresourceLoadDisallowed() override {
     ++disallowed_notification_count_;
   }
 
-  bool ShouldSuppressActivation(
-      content::NavigationHandle* navigation_handle) override {
-    ++attempted_frame_activations_;
-    return urls_to_suppress_activation_.find(navigation_handle->GetURL()) !=
-           urls_to_suppress_activation_.end();
-  }
-
  private:
   testing::TestRulesetCreator test_ruleset_creator_;
   testing::TestRulesetPair test_ruleset_pair_;
 
-  std::set<GURL> urls_to_suppress_activation_;
-
   std::unique_ptr<VerifiedRulesetDealer::Handle> dealer_handle_;
 
   std::unique_ptr<ContentSubresourceFilterThrottleManager> throttle_manager_;
 
   std::unique_ptr<content::NavigationSimulator> navigation_simulator_;
 
   // Incremented on every OnFirstSubresourceLoadDisallowed call.
   int disallowed_notification_count_ = 0;
 
-  // Incremented  every time the manager queries the harness for activation
-  // suppression.
-  int attempted_frame_activations_ = 0;
-
   DISALLOW_COPY_AND_ASSIGN(ContentSubresourceFilterThrottleManagerTest);
 };
 
 INSTANTIATE_TEST_CASE_P(PageActivationNotificationTiming,
                         ContentSubresourceFilterThrottleManagerTest,
                         ::testing::Values(WILL_START_REQUEST,
                                           WILL_PROCESS_RESPONSE));
 
 TEST_P(ContentSubresourceFilterThrottleManagerTest,
        ActivateMainFrameAndFilterSubframeNavigation) {
   // Commit a navigation that triggers page level activation.
   NavigateAndCommitMainFrame(GURL(kTestURLWithActivation));
   ExpectActivationSignalForFrame(main_rfh(), true /* expect_activation */);
 
   // A disallowed subframe navigation should be successfully filtered.
   CreateSubframeWithTestNavigation(
       GURL("https://www.example.com/disallowed.html"), main_rfh());
   SimulateStartAndExpectResult(content::NavigationThrottle::CANCEL);
 
   EXPECT_EQ(1, disallowed_notification_count());
-  EXPECT_EQ(1, attempted_frame_activations());
 }
 
 TEST_P(ContentSubresourceFilterThrottleManagerTest,
        ActivateMainFrameAndDoNotFilterDryRun) {
   // Commit a navigation that triggers page level activation.
   NavigateAndCommitMainFrame(GURL(kTestURLWithDryRun));
   ExpectActivationSignalForFrame(main_rfh(), true /* expect_activation */);
 
   // A disallowed subframe navigation should not be filtered in dry-run mode.
   CreateSubframeWithTestNavigation(
       GURL("https://www.example.com/disallowed.html"), main_rfh());
   SimulateStartAndExpectResult(content::NavigationThrottle::PROCEED);
   content::RenderFrameHost* child =
       SimulateCommitAndExpectResult(content::NavigationThrottle::PROCEED);
   // But it should still be activated.
   ExpectActivationSignalForFrame(child, true /* expect_activation */);
 
   EXPECT_EQ(0, disallowed_notification_count());
-  EXPECT_EQ(2, attempted_frame_activations());
 }
 
 TEST_P(ContentSubresourceFilterThrottleManagerTest,
        ActivateMainFrameAndFilterSubframeNavigationOnRedirect) {
   // Commit a navigation that triggers page level activation.
   NavigateAndCommitMainFrame(GURL(kTestURLWithActivation));
   ExpectActivationSignalForFrame(main_rfh(), true /* expect_activation */);
 
   // A disallowed subframe navigation via redirect should be successfully
   // filtered.
   CreateSubframeWithTestNavigation(
       GURL("https://www.example.com/before-redirect.html"), main_rfh());
   SimulateStartAndExpectResult(content::NavigationThrottle::PROCEED);
   SimulateRedirectAndExpectResult(
       GURL("https://www.example.com/disallowed.html"),
       content::NavigationThrottle::CANCEL);
 
   EXPECT_EQ(1, disallowed_notification_count());
-  EXPECT_EQ(1, attempted_frame_activations());
 }
 
 TEST_P(ContentSubresourceFilterThrottleManagerTest,
        ActivateMainFrameAndDoNotFilterSubframeNavigation) {
   // Commit a navigation that triggers page level activation.
   NavigateAndCommitMainFrame(GURL(kTestURLWithActivation));
   ExpectActivationSignalForFrame(main_rfh(), true /* expect_activation */);
 
   // An allowed subframe navigation should complete successfully.
   CreateSubframeWithTestNavigation(
       GURL("https://www.example.com/allowed1.html"), main_rfh());
   SimulateStartAndExpectResult(content::NavigationThrottle::PROCEED);
   SimulateRedirectAndExpectResult(GURL("https://www.example.com/allowed2.html"),
                                   content::NavigationThrottle::PROCEED);
   content::RenderFrameHost* child =
       SimulateCommitAndExpectResult(content::NavigationThrottle::PROCEED);
   ExpectActivationSignalForFrame(child, true /* expect_activation */);
 
   EXPECT_EQ(0, disallowed_notification_count());
-  EXPECT_EQ(2, attempted_frame_activations());
 }
 
 // This should fail if the throttle manager notifies the delegate twice of a
 // disallowed load for the same page load.
 TEST_P(ContentSubresourceFilterThrottleManagerTest,
        ActivateMainFrameAndFilterTwoSubframeNavigations) {
   // Commit a navigation that triggers page level activation.
   NavigateAndCommitMainFrame(GURL(kTestURLWithActivation));
   ExpectActivationSignalForFrame(main_rfh(), true /* expect_activation */);
 
   // A disallowed subframe navigation should be successfully filtered.
   CreateSubframeWithTestNavigation(
       GURL("https://www.example.com/1/disallowed.html"), main_rfh());
   SimulateStartAndExpectResult(content::NavigationThrottle::CANCEL);
 
   EXPECT_EQ(1, disallowed_notification_count());
 
   CreateSubframeWithTestNavigation(
       GURL("https://www.example.com/2/disallowed.html"), main_rfh());
   SimulateStartAndExpectResult(content::NavigationThrottle::CANCEL);
 
   EXPECT_EQ(1, disallowed_notification_count());
-  EXPECT_EQ(1, attempted_frame_activations());
 }
 
 TEST_P(ContentSubresourceFilterThrottleManagerTest,
        ActivateTwoMainFramesAndFilterTwoSubframeNavigations) {
   // Commit a navigation that triggers page level activation.
   NavigateAndCommitMainFrame(GURL(kTestURLWithActivation));
   ExpectActivationSignalForFrame(main_rfh(), true /* expect_activation */);
 
   // A disallowed subframe navigation should be successfully filtered.
   CreateSubframeWithTestNavigation(
       GURL("https://www.example.com/1/disallowed.html"), main_rfh());
   SimulateStartAndExpectResult(content::NavigationThrottle::CANCEL);
 
   EXPECT_EQ(1, disallowed_notification_count());
 
   // Commit another navigation that triggers page level activation.
   NavigateAndCommitMainFrame(GURL(kTestURLWithActivation2));
   ExpectActivationSignalForFrame(main_rfh(), true /* expect_activation */);
 
   CreateSubframeWithTestNavigation(
       GURL("https://www.example.com/2/disallowed.html"), main_rfh());
   SimulateStartAndExpectResult(content::NavigationThrottle::CANCEL);
 
   EXPECT_EQ(2, disallowed_notification_count());
-  EXPECT_EQ(2, attempted_frame_activations());
 }
 
 // Test that the disallow load notification will not be repeated for the first
 // disallowed load that follows a same-document navigation.
 TEST_P(ContentSubresourceFilterThrottleManagerTest,
        ActivateMainFrameDoNotNotifyAfterSameDocumentNav) {
   // Commit a navigation that triggers page level activation.
   NavigateAndCommitMainFrame(GURL(kTestURLWithActivation));
   ExpectActivationSignalForFrame(main_rfh(), true /* expect_activation */);
 
   // A disallowed subframe navigation should be successfully filtered.
   CreateSubframeWithTestNavigation(
       GURL("https://www.example.com/1/disallowed.html"), main_rfh());
   SimulateStartAndExpectResult(content::NavigationThrottle::CANCEL);
 
   EXPECT_EQ(1, disallowed_notification_count());
 
   // Commit another navigation that triggers page level activation.
   GURL url2 = GURL(base::StringPrintf("%s#ref", kTestURLWithActivation));
   CreateTestNavigation(url2, main_rfh());
   SimulateSameDocumentCommit();
   ExpectActivationSignalForFrame(main_rfh(), false /* expect_activation */);
 
   CreateSubframeWithTestNavigation(
       GURL("https://www.example.com/2/disallowed.html"), main_rfh());
   SimulateStartAndExpectResult(content::NavigationThrottle::CANCEL);
 
   EXPECT_EQ(1, disallowed_notification_count());
-  EXPECT_EQ(1, attempted_frame_activations());
 }
 
 TEST_P(ContentSubresourceFilterThrottleManagerTest,
        DoNotFilterForInactiveFrame) {
   NavigateAndCommitMainFrame(GURL("https://do-not-activate.html"));
   ExpectActivationSignalForFrame(main_rfh(), false /* expect_activation */);
 
   // A subframe navigation should complete successfully.
   CreateSubframeWithTestNavigation(GURL("https://www.example.com/allowed.html"),
                                    main_rfh());
   SimulateStartAndExpectResult(content::NavigationThrottle::PROCEED);
   content::RenderFrameHost* child =
       SimulateCommitAndExpectResult(content::NavigationThrottle::PROCEED);
   ExpectActivationSignalForFrame(child, false /* expect_activation */);
 
   EXPECT_EQ(0, disallowed_notification_count());
-  EXPECT_EQ(0, attempted_frame_activations());
-}
-
-TEST_P(ContentSubresourceFilterThrottleManagerTest, SuppressActivation) {
-  SuppressActivationForUrl(GURL(kTestURLWithActivation));
-  NavigateAndCommitMainFrame(GURL(kTestURLWithActivation));
-  ExpectActivationSignalForFrame(main_rfh(), false /* expect_activation */);
-
-  // A subframe navigation should complete successfully.
-  CreateSubframeWithTestNavigation(GURL("https://www.example.com/allowed.html"),
-                                   main_rfh());
-  SimulateStartAndExpectResult(content::NavigationThrottle::PROCEED);
-  content::RenderFrameHost* child =
-      SimulateCommitAndExpectResult(content::NavigationThrottle::PROCEED);
-  ExpectActivationSignalForFrame(child, false /* expect_activation */);
-
-  EXPECT_EQ(0, disallowed_notification_count());
-  EXPECT_EQ(1, attempted_frame_activations());
 }
 
 // Once there are no activated frames, the manager drops its ruleset handle. If
 // another frame is activated, make sure the handle is regenerated.
 TEST_P(ContentSubresourceFilterThrottleManagerTest, RulesetHandleRegeneration) {
   NavigateAndCommitMainFrame(GURL(kTestURLWithActivation));
   ExpectActivationSignalForFrame(main_rfh(), true /* expect_activation */);
 
   CreateSubframeWithTestNavigation(
       GURL("https://www.example.com/disallowed.html"), main_rfh());
   SimulateStartAndExpectResult(content::NavigationThrottle::CANCEL);
 
   EXPECT_EQ(1, disallowed_notification_count());
 
   // Simulate a renderer crash which should delete the frame.
   EXPECT_TRUE(ManagerHasRulesetHandle());
   process()->SimulateCrash();
   EXPECT_FALSE(ManagerHasRulesetHandle());
 
   NavigateAndCommit(GURL("https://example.reset"));
   NavigateAndCommitMainFrame(GURL(kTestURLWithActivation));
   ExpectActivationSignalForFrame(main_rfh(), true /* expect_activation */);
 
   CreateSubframeWithTestNavigation(
       GURL("https://www.example.com/disallowed.html"), main_rfh());
   SimulateStartAndExpectResult(content::NavigationThrottle::CANCEL);
 
   EXPECT_EQ(2, disallowed_notification_count());
-  EXPECT_EQ(2, attempted_frame_activations());
 }
 
 TEST_P(ContentSubresourceFilterThrottleManagerTest,
        SameSiteNavigation_RulesetGoesAway) {
   GURL same_site_inactive_url =
-      GURL(base::StringPrintf("%ssuppressed.html", kTestURLWithActivation));
-  SuppressActivationForUrl(same_site_inactive_url);
+      GURL(base::StringPrintf("%sinactive.html", kTestURLWithActivation));
 
   NavigateAndCommitMainFrame(GURL(kTestURLWithActivation));
   ExpectActivationSignalForFrame(main_rfh(), true /* expect_activation */);
   EXPECT_TRUE(ManagerHasRulesetHandle());
 
   NavigateAndCommitMainFrame(same_site_inactive_url);
   ExpectActivationSignalForFrame(main_rfh(), false /* expect_activation */);
   EXPECT_FALSE(ManagerHasRulesetHandle());
 
   // A subframe navigation should complete successfully.
   CreateSubframeWithTestNavigation(
       GURL("https://www.example.com/disallowed.html"), main_rfh());
   SimulateStartAndExpectResult(content::NavigationThrottle::PROCEED);
   content::RenderFrameHost* child =
       SimulateCommitAndExpectResult(content::NavigationThrottle::PROCEED);
   ExpectActivationSignalForFrame(child, false /* expect_activation */);
 
   EXPECT_EQ(0, disallowed_notification_count());
-  EXPECT_EQ(1, attempted_frame_activations());
 }
 
 TEST_P(ContentSubresourceFilterThrottleManagerTest,
        SameSiteFailedNavigation_MaintainActivation) {
   NavigateAndCommitMainFrame(GURL(kTestURLWithActivation));
   ExpectActivationSignalForFrame(main_rfh(), true /* expect_activation */);
   EXPECT_TRUE(ManagerHasRulesetHandle());
 
   GURL same_site_inactive_url =
-      GURL(base::StringPrintf("%ssuppressed.html", kTestURLWithActivation));
-  SuppressActivationForUrl(same_site_inactive_url);
+      GURL(base::StringPrintf("%sinactive.html", kTestURLWithActivation));
 
   CreateTestNavigation(same_site_inactive_url, main_rfh());
   SimulateFailedNavigation(net::ERR_ABORTED);
   EXPECT_TRUE(ManagerHasRulesetHandle());
   ExpectActivationSignalForFrame(main_rfh(), false /* expect_activation */);
 
   // A subframe navigation fail.
   CreateSubframeWithTestNavigation(
       GURL("https://www.example.com/disallowed.html"), main_rfh());
   SimulateStartAndExpectResult(content::NavigationThrottle::CANCEL);
 
   EXPECT_EQ(1, disallowed_notification_count());
-  EXPECT_EQ(1, attempted_frame_activations());
 }
 
 TEST_P(ContentSubresourceFilterThrottleManagerTest,
        FailedNavigationToErrorPage_NoActivation) {
   NavigateAndCommitMainFrame(GURL(kTestURLWithActivation));
   ExpectActivationSignalForFrame(main_rfh(), true /* expect_activation */);
   EXPECT_TRUE(ManagerHasRulesetHandle());
 
   GURL same_site_inactive_url =
-      GURL(base::StringPrintf("%ssuppressed.html", kTestURLWithActivation));
-  SuppressActivationForUrl(same_site_inactive_url);
+      GURL(base::StringPrintf("%sinactive.html", kTestURLWithActivation));
 
   CreateTestNavigation(same_site_inactive_url, main_rfh());
   SimulateFailedNavigation(net::ERR_FAILED);
   EXPECT_FALSE(ManagerHasRulesetHandle());
   ExpectActivationSignalForFrame(main_rfh(), false /* expect_activation */);
 
   CreateSubframeWithTestNavigation(
       GURL("https://www.example.com/disallowed.html"), main_rfh());
   SimulateStartAndExpectResult(content::NavigationThrottle::PROCEED);
   content::RenderFrameHost* child =
       SimulateCommitAndExpectResult(content::NavigationThrottle::PROCEED);
   ExpectActivationSignalForFrame(child, false /* expect_activation */);
 
   EXPECT_EQ(0, disallowed_notification_count());
-  EXPECT_EQ(1, attempted_frame_activations());
 }
 
 // Ensure activation propagates into great-grandchild frames, including cross
 // process ones.
 TEST_P(ContentSubresourceFilterThrottleManagerTest, ActivationPropagation) {
   NavigateAndCommitMainFrame(GURL(kTestURLWithActivation));
   ExpectActivationSignalForFrame(main_rfh(), true /* expect_activation */);
 
   // Navigate a subframe to a URL that is not itself disallowed. Subresource
   // filtering for this subframe document should still be activated.
@@ skipping 12 matching lines @@
   content::RenderFrameHost* subframe2 =
       SimulateCommitAndExpectResult(content::NavigationThrottle::PROCEED);
   ExpectActivationSignalForFrame(subframe2, true /* expect_activation */);
 
   // A final, nested subframe navigation is filtered.
   CreateSubframeWithTestNavigation(GURL("https://www.c.com/disallowed.html"),
                                    subframe2);
   SimulateStartAndExpectResult(content::NavigationThrottle::CANCEL);
 
   EXPECT_EQ(1, disallowed_notification_count());
-  EXPECT_EQ(3, attempted_frame_activations());
 }
 
 // Ensure activation propagates through whitelisted documents.
 TEST_P(ContentSubresourceFilterThrottleManagerTest, ActivationPropagation2) {
   NavigateAndCommitMainFrame(GURL(kTestURLWithActivation));
   ExpectActivationSignalForFrame(main_rfh(), true /* expect_activation */);
 
   // Navigate a subframe that is not filtered, but should still activate.
   CreateSubframeWithTestNavigation(GURL("https://whitelist.com"), main_rfh());
   SimulateStartAndExpectResult(content::NavigationThrottle::PROCEED);
   content::RenderFrameHost* subframe1 =
       SimulateCommitAndExpectResult(content::NavigationThrottle::PROCEED);
   ExpectActivationSignalForFrame(subframe1, true /* expect_activation */);
 
   // Navigate a sub-subframe that is not filtered due to the whitelist.
   CreateSubframeWithTestNavigation(
       GURL("https://www.example.com/disallowed.html"), subframe1);
   SimulateStartAndExpectResult(content::NavigationThrottle::PROCEED);
   content::RenderFrameHost* subframe2 =
       SimulateCommitAndExpectResult(content::NavigationThrottle::PROCEED);
   ExpectActivationSignalForFrame(subframe2, true /* expect_activation */);
 
-  EXPECT_EQ(3, attempted_frame_activations());
   EXPECT_EQ(0, disallowed_notification_count());
 
   // An identical series of events that don't match whitelist rules cause
   // filtering.
   CreateSubframeWithTestNavigation(GURL("https://average-joe.com"), main_rfh());
   SimulateStartAndExpectResult(content::NavigationThrottle::PROCEED);
   content::RenderFrameHost* subframe3 =
       SimulateCommitAndExpectResult(content::NavigationThrottle::PROCEED);
   ExpectActivationSignalForFrame(subframe3, true /* expect_activation */);
 
   // Navigate a sub-subframe that is not filtered due to the whitelist.
   CreateSubframeWithTestNavigation(
       GURL("https://www.example.com/disallowed.html"), subframe3);
   SimulateStartAndExpectResult(content::NavigationThrottle::CANCEL);
 
-  EXPECT_EQ(4, attempted_frame_activations());
   EXPECT_EQ(1, disallowed_notification_count());
 }
 
 // Same-site navigations within a single RFH do not persist activation.
 TEST_P(ContentSubresourceFilterThrottleManagerTest,
        SameSiteNavigationStopsActivation) {
   NavigateAndCommitMainFrame(GURL(kTestURLWithActivation));
   ExpectActivationSignalForFrame(main_rfh(), true /* expect_activation */);
-  EXPECT_EQ(1, attempted_frame_activations());
 
   // Mock a same-site navigation, in the same RFH, this URL does not trigger
   // page level activation.
   NavigateAndCommitMainFrame(
       GURL(base::StringPrintf("%s/some_path/", kTestURLWithActivation)));
-  EXPECT_EQ(1, attempted_frame_activations());
   ExpectActivationSignalForFrame(main_rfh(), false /* expect_activation */);
 
   CreateSubframeWithTestNavigation(
       GURL("https://www.example.com/disallowed.html"), main_rfh());
   SimulateStartAndExpectResult(content::NavigationThrottle::PROCEED);
   content::RenderFrameHost* child =
       SimulateCommitAndExpectResult(content::NavigationThrottle::PROCEED);
   ExpectActivationSignalForFrame(child, false /* expect_activation */);
 
   EXPECT_EQ(0, disallowed_notification_count());
-  EXPECT_EQ(1, attempted_frame_activations());
 }
 
 // TODO(csharrison): Make sure the following conditions are exercised in tests:
 //
 // - Synchronous navigations to about:blank. These hit issues with the
 //   NavigationSimulator currently.
 
 }  // namespace subresource_filter