Update Content Blocking to use BSK stack

DuckDuckGo.xcodeproj/project.xcworkspace/xcshareddata/swiftpm/Package.resolved

@@ -5,8 +5,8 @@
         "package": "BrowserServicesKit",
         "repositoryURL": "https://github.com/duckduckgo/BrowserServicesKit.git",
         "state": {
-          "branch": "release/friends-and-family",
-          "revision": "aeb2dc2fc19c75dcca1b0727a2b078742ebac280",
+          "branch": "bartek/content-blocking",
+          "revision": "62bece25ef650c2fca539310c4ea9d7e85b3884f",
           "version": null
         }
       },

DuckDuckGo/BrowserTab/Model/NavigatorCredentialsUserScript.swift

@@ -22,7 +22,7 @@ import WebKit
 public final class NavigatorCredentialsUserScript: NSObject, UserScript {
     public let messageNames: [String] = []
 
-    init(scriptSource: ScriptSourceProviding = DefaultScriptSourceProvider.shared) {
+    init(scriptSource: ScriptSourceProviding) {
         source = scriptSource.navigatorCredentialsSource
     }
 

DuckDuckGo/BrowserTab/Model/Tab.swift

@@ -92,6 +92,7 @@ final class Tab: NSObject {
          webCacheManager: WebCacheManager = WebCacheManager.shared,
          webViewConfiguration: WebViewConfiguration? = nil,
          historyCoordinating: HistoryCoordinating = HistoryCoordinator.shared,
+         scriptsSource: ScriptSourceProviding = DefaultScriptSourceProvider.shared,
          visitedDomains: Set<String> = Set<String>(),
          title: String? = nil,
          error: Error? = nil,
@@ -104,6 +105,7 @@ final class Tab: NSObject {
         self.content = content
         self.faviconService = faviconService
         self.historyCoordinating = historyCoordinating
+        self.scriptsSource = scriptsSource
         self.visitedDomains = visitedDomains
         self.title = title
         self.error = error
@@ -343,7 +345,7 @@ final class Tab: NSObject {
         webView.allowsBackForwardNavigationGestures = true
         webView.allowsMagnification = true
 
-        subscribeToUserScripts()
+        subscribeToUserScriptChanges()
         subscribeToOpenExternalUrlEvents()
 
         superviewObserver = webView.observe(\.superview, options: .old) { [weak self] _, change in
@@ -403,7 +405,10 @@ final class Tab: NSObject {
     }
 
     // MARK: - User Scripts
-
+
+    let scriptsSource: ScriptSourceProviding
+    private var userScriptsUpdatedCancellable: AnyCancellable?
+
     lazy var emailManager: EmailManager = {
         let emailManager = EmailManager()
         emailManager.requestDelegate = self
@@ -416,8 +421,6 @@ final class Tab: NSObject {
         return manager
     }()
 
-    private var userScriptsUpdatedCancellable: AnyCancellable?
-
     private var userScripts: UserScripts! {
         willSet {
             if let userScripts = userScripts {
@@ -428,7 +431,7 @@ final class Tab: NSObject {
             userScripts.debugScript.instrumentation = instrumentation
             userScripts.faviconScript.delegate = self
             userScripts.contextMenuScript.delegate = self
-            userScripts.contentBlockerScript.delegate = self
+            userScripts.surrogatesScript.delegate = self
             userScripts.contentBlockerRulesScript.delegate = self
             userScripts.autofillScript.emailDelegate = emailManager
             userScripts.autofillScript.vaultDelegate = vaultManager
@@ -442,11 +445,12 @@ final class Tab: NSObject {
         }
     }
 
-    private func subscribeToUserScripts() {
-        userScriptsUpdatedCancellable = UserScriptsManager.shared
-            .$userScripts
-            .map(UserScripts.init(copy:))
-            .weakAssign(to: \.userScripts, on: self)
+    private func subscribeToUserScriptChanges() {
+        userScriptsUpdatedCancellable = scriptsSource.sourceUpdatedPublisher.receive(on: RunLoop.main).sink { [weak self] _ in
+            guard let self = self, self.delegate != nil else { return }
+
+            self.userScripts = UserScripts(with: self.scriptsSource)
+        }
     }
 
     // MARK: - Find in Page
@@ -596,24 +600,28 @@ extension Tab: FaviconUserScriptDelegate {
 
 }
 
-extension Tab: ContentBlockerUserScriptDelegate {
+extension Tab: ContentBlockerRulesUserScriptDelegate {
 
-    func contentBlockerUserScriptShouldProcessTrackers(_ script: UserScript) -> Bool {
+    func contentBlockerRulesUserScriptShouldProcessTrackers(_ script: ContentBlockerRulesUserScript) -> Bool {
         return true
     }
 
-    func contentBlockerUserScript(_ script: ContentBlockerUserScript,
-                                  detectedTracker tracker: DetectedTracker,
-                                  withSurrogate host: String) {
-        trackerInfo?.add(installedSurrogateHost: host)
+    func contentBlockerRulesUserScript(_ script: ContentBlockerRulesUserScript, detectedTracker tracker: DetectedTracker) {
+        trackerInfo?.add(detectedTracker: tracker)
+    }
+}
+
+extension Tab: SurrogatesUserScriptDelegate {
 
-        contentBlockerUserScript(script, detectedTracker: tracker)
+    func surrogatesUserScriptShouldProcessTrackers(_ script: SurrogatesUserScript) -> Bool {
+        return true
     }
 
-    func contentBlockerUserScript(_ script: UserScript, detectedTracker tracker: DetectedTracker) {
+    func surrogatesUserScript(_ script: SurrogatesUserScript, detectedTracker tracker: DetectedTracker, withSurrogate host: String) {
+        trackerInfo?.add(installedSurrogateHost: host)
+
         trackerInfo?.add(detectedTracker: tracker)
     }
-
 }
 
 extension Tab: EmailManagerRequestDelegate { }

DuckDuckGo/BrowserTab/Model/UserContentController.swift

@@ -18,15 +18,16 @@
 
 import WebKit
 import Combine
+import BrowserServicesKit
 
 final class UserContentController: WKUserContentController {
     private var blockingRulesUpdatedCancellable: AnyCancellable?
 
-    let privacyConfiguration: PrivacyConfigurationManagment
+    let privacyConfigurationManager: PrivacyConfigurationManager
 
-    public init(rulesPublisher: AnyPublisher<WKContentRuleList?, Never> = ContentBlockerRulesManager.shared.blockingRules,
-                privacyConfiguration: PrivacyConfigurationManagment = PrivacyConfigurationManager.shared) {
-        self.privacyConfiguration = privacyConfiguration
+    public init(rulesPublisher: ContentBlockingUpdating.NewRulesPublisher = ContentBlocking.contentBlockingUpdating.contentBlockingRules,
+                privacyConfigurationManager: PrivacyConfigurationManager = ContentBlocking.privacyConfigurationManager) {
+        self.privacyConfigurationManager = privacyConfigurationManager
         super.init()
 
         installContentBlockingRules(publisher: rulesPublisher)
@@ -36,17 +37,17 @@ final class UserContentController: WKUserContentController {
         fatalError("init(coder:) has not been implemented")
     }
 
-    func installContentBlockingRules(publisher: AnyPublisher<WKContentRuleList?, Never>) {
-        blockingRulesUpdatedCancellable = publisher.receive(on: RunLoop.main).sink { [weak self] rules in
+    func installContentBlockingRules(publisher: ContentBlockingUpdating.NewRulesPublisher) {
+        blockingRulesUpdatedCancellable = publisher.receive(on: RunLoop.main).sink { [weak self] newRules in
             dispatchPrecondition(condition: .onQueue(.main))
 
             guard let self = self,
-                  let rules = rules
+                  let newRules = newRules
             else { return }
 
             self.removeAllContentRuleLists()
-            if self.privacyConfiguration.isEnabled(featureKey: .contentBlocking) {
-                self.add(rules)
+            if self.privacyConfigurationManager.privacyConfig.isEnabled(featureKey: .contentBlocking) {
+                self.add(newRules.rules.rulesList)
             }
         }
     }

DuckDuckGo/BrowserTab/Model/UserScripts.swift

@@ -18,44 +18,45 @@
 
 import Foundation
 import BrowserServicesKit
+import TrackerRadarKit
 
 final class UserScripts {
 
     let pageObserverScript = PageObserverUserScript()
     let faviconScript = FaviconUserScript()
     let contextMenuScript = ContextMenuUserScript()
     let findInPageScript = FindInPageUserScript()
-    let contentBlockerScript = ContentBlockerUserScript()
-    let contentBlockerRulesScript = ContentBlockerRulesUserScript()
-    let autofillScript = AutofillUserScript()
     let printingUserScript = PrintingUserScript()
     let hoverUserScript = HoverUserScript()
-    let navigatorCredentialsUserScript = NavigatorCredentialsUserScript()
     let debugScript = DebugUserScript()
-    let gpcScript = GPCUserScript()
+    let autofillScript = AutofillUserScript()
 
-    init() {
-    }
+    let contentBlockerRulesScript: ContentBlockerRulesUserScript
+    let surrogatesScript: SurrogatesUserScript
+    let navigatorCredentialsUserScript: NavigatorCredentialsUserScript
+    let gpcScript: GPCUserScript
+
+    init(with sourceProvider: ScriptSourceProviding) {
 
-    init(copy other: UserScripts) {
-        scripts = other.scripts
-        scripts.removeLast()
-        scripts.append(autofillScript.makeWKUserScript())
+        contentBlockerRulesScript = ContentBlockerRulesUserScript(configuration: sourceProvider.contentBlockerRulesConfig!)
+        surrogatesScript = SurrogatesUserScript(configuration: sourceProvider.surrogatesConfig!)
+        navigatorCredentialsUserScript = NavigatorCredentialsUserScript(scriptSource: sourceProvider)
+        gpcScript = GPCUserScript(scriptSource: sourceProvider)
     }
 
     lazy var userScripts: [UserScript] = [
-        self.debugScript,
-        self.faviconScript,
-        self.contextMenuScript,
-        self.findInPageScript,
-        self.contentBlockerScript,
-        self.contentBlockerRulesScript,
-        self.pageObserverScript,
-        self.printingUserScript,
-        self.hoverUserScript,
-        self.gpcScript,
-        self.navigatorCredentialsUserScript,
-        self.autofillScript
+        debugScript,
+        faviconScript,
+        contextMenuScript,
+        findInPageScript,
+        surrogatesScript,
+        contentBlockerRulesScript,
+        pageObserverScript,
+        printingUserScript,
+        hoverUserScript,
+        gpcScript,
+        navigatorCredentialsUserScript,
+        autofillScript
     ]
 
     lazy var scripts = userScripts.map { $0.makeWKUserScript() }

DuckDuckGo/Common/Extensions/URLExtension.swift

@@ -18,6 +18,7 @@
 
 import Foundation
 import os.log
+import BrowserServicesKit
 
 extension URL {
 
@@ -437,29 +438,27 @@ extension URL {
     }
 
     // MARK: - GPC
+
+    static func gpcHeadersEnabled(config: PrivacyConfiguration) -> [String] {
+        let settings = config.settings(for: .gpc)
+
+        guard let enabledSites = settings["gpcHeaderEnabledSites"] as? [String] else {
+            return []
+        }
+
+        return enabledSites
+    }
 
     static func isGPCEnabled(url: URL,
-                             config: PrivacyConfigurationManager = PrivacyConfigurationManager.shared) -> Bool {
-        let enabledSites = config.gpcHeadersEnabled()
+                             config: PrivacyConfiguration = ContentBlocking.privacyConfigurationManager.privacyConfig) -> Bool {
+        let enabledSites = gpcHeadersEnabled(config: config)
 
         for gpcHost in enabledSites {
             if url.isPart(ofDomain: gpcHost) {
-
                 // Check if url is on exception list
                 // Since headers are only enabled for a small numbers of sites
                 // perfrom this check here for efficency
-                let exceptions = config.tempUnprotectedDomains + config.exceptionsList(forFeature: .gpc)
-                let protectionStore = DomainsProtectionUserDefaultsStore()
-                if protectionStore.unprotectedDomains.contains(url.host ?? "") {
-                    return false
-                }
-                for exception in exceptions {
-                    if url.isPart(ofDomain: exception) {
-                        return false
-                    }
-                }
-
-                return true
+                return config.isFeature(.gpc, enabledForDomain: url.host)
             }
         }