Deprecate ContentSubresourceFilterDriver.

components/subresource_filter/content/browser/content_subresource_filter_driver_factory.h

 // Copyright 2016 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.
 
 #ifndef COMPONENTS_SUBRESOURCE_FILTER_CONTENT_BROWSER_CONTENT_SUBRESOURCE_FILTER_DRIVER_FACTORY_H_
 #define COMPONENTS_SUBRESOURCE_FILTER_CONTENT_BROWSER_CONTENT_SUBRESOURCE_FILTER_DRIVER_FACTORY_H_
 
 #include <map>
 #include <set>
 #include <string>
@@ skipping 13 matching lines @@
 class WebContents;
 class RenderFrameHost;
 }  // namespace content
 
 namespace safe_browsing {
 class SafeBrowsingServiceTest;
 };
 
 namespace subresource_filter {
 
-class ContentSubresourceFilterDriver;
 class SubresourceFilterClient;
 enum class ActivationLevel;
 enum class ActivationList;
 
 using HostPathSet = std::set<std::string>;
 using URLToActivationListsMap =
     std::unordered_map<std::string, std::set<ActivationList>>;
 
 // Controls the activation of subresource filtering for each page load in a
-// WebContents and manufactures the per-frame ContentSubresourceFilterDrivers.
+// WebContents and is responsible for sending the activation signal to all the
+// per-frame SubresourceFilterAgents on the renderer side.
 class ContentSubresourceFilterDriverFactory
     : public base::SupportsUserData::Data,
       public content::WebContentsObserver {
  public:
   static void CreateForWebContents(
       content::WebContents* web_contents,
       std::unique_ptr<SubresourceFilterClient> client);
   static ContentSubresourceFilterDriverFactory* FromWebContents(
       content::WebContents* web_contents);
 
@@ skipping 17 matching lines @@
       safe_browsing::SBThreatType threat_type,
       safe_browsing::ThreatPatternType threat_type_metadata);
 
   // Reloads the page and inserts the host of its URL to the whitelist.
   void OnReloadRequested();
 
  private:
   friend class ContentSubresourceFilterDriverFactoryTest;
   friend class safe_browsing::SafeBrowsingServiceTest;
 
-  typedef std::map<content::RenderFrameHost*,
-                   std::unique_ptr<ContentSubresourceFilterDriver>>
-      FrameHostToOwnedDriverMap;
-
-  void SetDriverForFrameHostForTesting(
-      content::RenderFrameHost* render_frame_host,
-      std::unique_ptr<ContentSubresourceFilterDriver> driver);
-
-  void CreateDriverForFrameHostIfNeeded(
-      content::RenderFrameHost* render_frame_host);
-  ContentSubresourceFilterDriver* DriverFromFrameHost(
-      content::RenderFrameHost* render_frame_host);
-
   void ResetActivationState();
 
   void OnFirstSubresourceLoadDisallowed();
 
   void OnDocumentLoadStatistics(const DocumentLoadStatistics& statistics);
 
   bool IsWhitelisted(const GURL& url) const;
 
   // content::WebContentsObserver:
   void DidStartNavigation(
       content::NavigationHandle* navigation_handle) override;
   void DidRedirectNavigation(
       content::NavigationHandle* navigation_handle) override;
-  void RenderFrameCreated(content::RenderFrameHost* render_frame_host) override;
-  void RenderFrameDeleted(content::RenderFrameHost* render_frame_host) override;
   void ReadyToCommitNavigation(
       content::NavigationHandle* navigation_handle) override;
   void DidFinishLoad(content::RenderFrameHost* render_frame_host,
                      const GURL& validated_url) override;
   bool OnMessageReceived(const IPC::Message& message,
                          content::RenderFrameHost* render_frame_host) override;
 
   // Checks base on the value of |urr| and current activation scope if
   // activation signal should be sent.
   bool ShouldActivateForMainFrameURL(const GURL& url) const;
   void ActivateForFrameHostIfNeeded(content::RenderFrameHost* render_frame_host,
                                     const GURL& url,
                                     bool failed_navigation);
 
   // Internal implementation of ReadyToCommitNavigation which doesn't use
   // NavigationHandle to ease unit tests.
   void ReadyToCommitNavigationInternal(
       content::RenderFrameHost* render_frame_host,
       const GURL& url,
       const content::Referrer& referrer,
       ui::PageTransition page_transition,
       bool failed_navigation);
 
   bool DidURLMatchCurrentActivationList(const GURL& url) const;
 
   void AddActivationListMatch(const GURL& url, ActivationList match_type);
   void RecordRedirectChainMatchPattern() const;
 
-  FrameHostToOwnedDriverMap frame_drivers_;
   std::unique_ptr<SubresourceFilterClient> client_;
 
   HostPathSet whitelisted_hosts_;
 
   ActivationLevel activation_level_;
   bool measure_performance_;
 
   // The URLs in the navigation chain.
   std::vector<GURL> navigation_chain_;
 
   URLToActivationListsMap activation_list_matches_;
 
   // Statistics about subresource loads, aggregated across all frames of the
   // current page.
   DocumentLoadStatistics aggregated_document_statistics_;
 
   DISALLOW_COPY_AND_ASSIGN(ContentSubresourceFilterDriverFactory);
 };
 
 }  // namespace subresource_filter
 
 #endif  // COMPONENTS_SUBRESOURCE_FILTER_CONTENT_BROWSER_CONTENT_SUBRESOURCE_FILTER_DRIVER_FACTORY_H_