Closes mozilla-mobile#4098, mozilla-mobile#4110: Exposing new categor…

…ies of content blocking.

buildSrc/src/main/java/Gecko.kt

@@ -6,7 +6,7 @@ internal object GeckoVersions {
     /**
      * GeckoView Nightly Version.
      */
-    const val nightly_version = "70.0.20190809095611"
+    const val nightly_version = "70.0.20190813095543"
 
     /**
      * GeckoView Beta Version.

components/browser/engine-gecko-beta/src/main/java/mozilla/components/browser/engine/gecko/GeckoEngine.kt

@@ -156,13 +156,17 @@ class GeckoEngine(
                 defaultSettings?.automaticLanguageAdjustment = value
             }
 
-        override var trackingProtectionPolicy: TrackingProtectionPolicy?
-            get() = TrackingProtectionPolicy.select(runtime.settings.contentBlocking.categories)
+        override var trackingProtectionPolicy: TrackingProtectionPolicy? = null
             set(value) {
-                value?.let {
-                    runtime.settings.contentBlocking.categories = it.categories
-                    runtime.settings.contentBlocking.cookieBehavior = it.cookiePolicy.id
+                value?.let { policy ->
+
+                    val trackingCategories = policy.trackingCategories.sumBy { it.id } +
+                        policy.safeBrowsingCategories.sumBy { it.id }
+
+                    runtime.settings.contentBlocking.categories = trackingCategories
+                    runtime.settings.contentBlocking.cookieBehavior = policy.cookiePolicy.id
                     defaultSettings?.trackingProtectionPolicy = value
+                    field = value
                 }
             }
 

components/browser/engine-gecko-beta/src/main/java/mozilla/components/browser/engine/gecko/GeckoEngineSession.kt

@@ -574,29 +574,33 @@ class GeckoEngineSession(
     }
 
     private fun ContentBlocking.BlockEvent.toTracker(): Tracker {
-        val blockedContentCategories = ArrayList<Tracker.Category>()
+        val blockedContentCategories = mutableListOf<TrackingProtectionPolicy.TrackingCategory>()
 
         if (categories.contains(ContentBlocking.AT_AD)) {
-            blockedContentCategories.add(Tracker.Category.Ad)
+            blockedContentCategories.add(TrackingProtectionPolicy.TrackingCategory.AD)
         }
 
         if (categories.contains(ContentBlocking.AT_ANALYTIC)) {
-            blockedContentCategories.add(Tracker.Category.Analytic)
+            blockedContentCategories.add(TrackingProtectionPolicy.TrackingCategory.ANALYTICS)
         }
 
         if (categories.contains(ContentBlocking.AT_SOCIAL)) {
-            blockedContentCategories.add(Tracker.Category.Social)
+            blockedContentCategories.add(TrackingProtectionPolicy.TrackingCategory.SOCIAL)
         }
 
         if (categories.contains(ContentBlocking.AT_FINGERPRINTING)) {
-            blockedContentCategories.add(Tracker.Category.Fingerprinting)
+            blockedContentCategories.add(TrackingProtectionPolicy.TrackingCategory.FINGERPRINTING)
         }
 
         if (categories.contains(ContentBlocking.AT_CRYPTOMINING)) {
-            blockedContentCategories.add(Tracker.Category.Cryptomining)
+            blockedContentCategories.add(TrackingProtectionPolicy.TrackingCategory.CRYPTOMINING)
         }
         if (categories.contains(ContentBlocking.AT_CONTENT)) {
-            blockedContentCategories.add(Tracker.Category.Content)
+            blockedContentCategories.add(TrackingProtectionPolicy.TrackingCategory.CONTENT)
+        }
+
+        if (categories.contains(ContentBlocking.AT_TEST)) {
+            blockedContentCategories.add(TrackingProtectionPolicy.TrackingCategory.TEST)
         }
         return Tracker(uri, blockedContentCategories)
     }

components/browser/engine-gecko-beta/src/test/java/mozilla/components/browser/engine/gecko/GeckoEngineSessionTest.kt

@@ -14,6 +14,8 @@ import mozilla.components.concept.engine.DefaultSettings
 import mozilla.components.concept.engine.EngineSession
 import mozilla.components.concept.engine.EngineSession.LoadUrlFlags
 import mozilla.components.concept.engine.EngineSession.TrackingProtectionPolicy
+import mozilla.components.concept.engine.EngineSession.TrackingProtectionPolicy.TrackingCategory
+import mozilla.components.concept.engine.EngineSession.TrackingProtectionPolicy.SafeBrowsingCategory
 import mozilla.components.concept.engine.HitResult
 import mozilla.components.concept.engine.UnsupportedSettingException
 import mozilla.components.concept.engine.content.blocking.Tracker
@@ -801,12 +803,24 @@ class GeckoEngineSessionTest {
         geckoCatgories = geckoCatgories.or(ContentBlocking.AT_CRYPTOMINING)
         geckoCatgories = geckoCatgories.or(ContentBlocking.AT_FINGERPRINTING)
         geckoCatgories = geckoCatgories.or(ContentBlocking.AT_CONTENT)
+        geckoCatgories = geckoCatgories.or(ContentBlocking.AT_TEST)
 
         contentBlockingDelegate.value.onContentBlocked(geckoSession,
             ContentBlocking.BlockEvent("tracker1", geckoCatgories)
         )
         assertEquals("tracker1", trackerBlocked!!.url)
-        assertTrue(trackerBlocked!!.categories.containsAll(Tracker.Category.values().toList()))
+
+        val expectedBlockedCategories = listOf(
+            TrackingCategory.AD,
+            TrackingCategory.ANALYTICS,
+            TrackingCategory.SOCIAL,
+            TrackingCategory.CRYPTOMINING,
+            TrackingCategory.FINGERPRINTING,
+            TrackingCategory.CONTENT,
+            TrackingCategory.TEST
+        )
+
+        assertTrue(trackerBlocked!!.trackingCategories.containsAll(expectedBlockedCategories))
     }
 
     @Test
@@ -829,9 +843,14 @@ class GeckoEngineSessionTest {
             }
         })
 
-        val allPolicy = TrackingProtectionPolicy.select(TrackingProtectionPolicy.AD)
-        val regularOnlyPolicy = TrackingProtectionPolicy.select(TrackingProtectionPolicy.AD).forRegularSessionsOnly()
-        val privateOnlyPolicy = TrackingProtectionPolicy.select(TrackingProtectionPolicy.AD).forPrivateSessionsOnly()
+        val allPolicy = TrackingProtectionPolicy.select(
+            arrayOf(TrackingProtectionPolicy.TrackingCategory.AD))
+        val regularOnlyPolicy = TrackingProtectionPolicy.select(
+            trackingCategories = arrayOf(TrackingCategory.AD)
+        ).forRegularSessionsOnly()
+        val privateOnlyPolicy = TrackingProtectionPolicy.select(
+            trackingCategories = arrayOf(TrackingCategory.AD)
+        ).forPrivateSessionsOnly()
 
         session.enableTrackingProtection(allPolicy)
         assertTrue(trackerBlockingObserved)
@@ -871,21 +890,40 @@ class GeckoEngineSessionTest {
 
     @Test
     fun trackingProtectionCategoriesAreAligned() {
-        assertEquals(TrackingProtectionPolicy.AD, ContentBlocking.AT_AD)
-        assertEquals(TrackingProtectionPolicy.ANALYTICS, ContentBlocking.AT_ANALYTIC)
-        assertEquals(TrackingProtectionPolicy.CONTENT, ContentBlocking.AT_CONTENT)
-        assertEquals(TrackingProtectionPolicy.SOCIAL, ContentBlocking.AT_SOCIAL)
-        assertEquals(TrackingProtectionPolicy.TEST, ContentBlocking.AT_TEST)
-        assertEquals(TrackingProtectionPolicy.CRYPTOMINING, ContentBlocking.AT_CRYPTOMINING)
-        assertEquals(TrackingProtectionPolicy.FINGERPRINTING, ContentBlocking.AT_FINGERPRINTING)
-        assertEquals(TrackingProtectionPolicy.SAFE_BROWSING_ALL, ContentBlocking.SB_ALL)
-        assertEquals(TrackingProtectionPolicy.SAFE_BROWSING_HARMFUL, ContentBlocking.SB_HARMFUL)
-        assertEquals(TrackingProtectionPolicy.SAFE_BROWSING_MALWARE, ContentBlocking.SB_MALWARE)
-        assertEquals(TrackingProtectionPolicy.SAFE_BROWSING_PHISHING, ContentBlocking.SB_PHISHING)
-        assertEquals(TrackingProtectionPolicy.SAFE_BROWSING_UNWANTED, ContentBlocking.SB_UNWANTED)
-
-        assertEquals(TrackingProtectionPolicy.all().categories, ContentBlocking.CB_STRICT)
-        assertEquals(TrackingProtectionPolicy.recommended().categories, ContentBlocking.CB_DEFAULT)
+        assertEquals(TrackingCategory.AD.id, ContentBlocking.AT_AD)
+        assertEquals(TrackingCategory.ANALYTICS.id, ContentBlocking.AT_ANALYTIC)
+        assertEquals(TrackingCategory.CONTENT.id, ContentBlocking.AT_CONTENT)
+        assertEquals(TrackingCategory.SOCIAL.id, ContentBlocking.AT_SOCIAL)
+        assertEquals(TrackingCategory.TEST.id, ContentBlocking.AT_TEST)
+        assertEquals(TrackingCategory.CRYPTOMINING.id, ContentBlocking.AT_CRYPTOMINING)
+        assertEquals(TrackingCategory.FINGERPRINTING.id, ContentBlocking.AT_FINGERPRINTING)
+
+        assertEquals(SafeBrowsingCategory.RECOMMENDED.id, ContentBlocking.SB_ALL)
+        assertEquals(SafeBrowsingCategory.HARMFUL.id, ContentBlocking.SB_HARMFUL)
+        assertEquals(SafeBrowsingCategory.MALWARE.id, ContentBlocking.SB_MALWARE)
+        assertEquals(SafeBrowsingCategory.PHISHING.id, ContentBlocking.SB_PHISHING)
+        assertEquals(SafeBrowsingCategory.UNWANTED.id, ContentBlocking.SB_UNWANTED)
+
+        assertEquals(
+            TrackingProtectionPolicy.strict().trackingCategories.sumBy { it.id },
+            ContentBlocking.AT_STRICT
+        )
+
+        assertEquals(
+            TrackingProtectionPolicy.strict().safeBrowsingCategories.sumBy { it.id },
+            ContentBlocking.SB_ALL
+        )
+
+        assertEquals(
+            TrackingProtectionPolicy.recommended().trackingCategories.sumBy { it.id },
+            ContentBlocking.AT_DEFAULT
+        )
+
+        assertEquals(
+            TrackingProtectionPolicy.recommended().safeBrowsingCategories.sumBy { it.id },
+            ContentBlocking.SB_ALL
+        )
+
         assertEquals(TrackingProtectionPolicy.CookiePolicy.ACCEPT_ALL.id, ContentBlocking.COOKIE_ACCEPT_ALL)
         assertEquals(
             TrackingProtectionPolicy.CookiePolicy.ACCEPT_NON_TRACKERS.id,
@@ -990,7 +1028,7 @@ class GeckoEngineSessionTest {
         }
 
         expectException(UnsupportedSettingException::class) {
-            settings.trackingProtectionPolicy = TrackingProtectionPolicy.all()
+            settings.trackingProtectionPolicy = TrackingProtectionPolicy.strict()
         }
     }
 
@@ -1286,7 +1324,8 @@ class GeckoEngineSessionTest {
         val runtime = mock<GeckoRuntime>()
         whenever(runtime.settings).thenReturn(mock())
 
-        val defaultSettings = DefaultSettings(trackingProtectionPolicy = TrackingProtectionPolicy.all())
+        val defaultSettings =
+            DefaultSettings(trackingProtectionPolicy = TrackingProtectionPolicy.strict())
 
         GeckoEngineSession(runtime, geckoSessionProvider = geckoSessionProvider,
                 privateMode = false, defaultSettings = defaultSettings)

components/browser/engine-gecko-beta/src/test/java/mozilla/components/browser/engine/gecko/GeckoEngineTest.kt

@@ -68,8 +68,7 @@ class GeckoEngineTest {
     @Test
     fun settings() {
         val defaultSettings = DefaultSettings()
-        val contentBlockingSettings =
-                ContentBlocking.Settings.Builder().categories(TrackingProtectionPolicy.none().categories).build()
+        val contentBlockingSettings = ContentBlocking.Settings.Builder().build()
         val runtime = mock<GeckoRuntime>()
         val runtimeSettings = mock<GeckoRuntimeSettings>()
         whenever(runtimeSettings.javaScriptEnabled).thenReturn(true)
@@ -133,22 +132,15 @@ class GeckoEngineTest {
         engine.settings.userAgentString = engine.settings.userAgentString + "-test"
         assertEquals(GeckoSession.getDefaultUserAgent() + "-test", engine.settings.userAgentString)
 
-        assertEquals(TrackingProtectionPolicy.none(), engine.settings.trackingProtectionPolicy)
-        engine.settings.trackingProtectionPolicy = TrackingProtectionPolicy.all()
-        assertEquals(TrackingProtectionPolicy.select(
-                TrackingProtectionPolicy.AD,
-                TrackingProtectionPolicy.SOCIAL,
-                TrackingProtectionPolicy.ANALYTICS,
-                TrackingProtectionPolicy.CONTENT,
-                TrackingProtectionPolicy.TEST,
-                TrackingProtectionPolicy.CRYPTOMINING,
-                TrackingProtectionPolicy.FINGERPRINTING,
-                TrackingProtectionPolicy.SAFE_BROWSING_HARMFUL,
-                TrackingProtectionPolicy.SAFE_BROWSING_UNWANTED,
-                TrackingProtectionPolicy.SAFE_BROWSING_MALWARE,
-                TrackingProtectionPolicy.SAFE_BROWSING_PHISHING
-        ).categories, contentBlockingSettings.categories)
-        assertEquals(defaultSettings.trackingProtectionPolicy, TrackingProtectionPolicy.all())
+        assertEquals(null, engine.settings.trackingProtectionPolicy)
+
+        engine.settings.trackingProtectionPolicy = TrackingProtectionPolicy.strict()
+
+        val trackingStrictCategories = TrackingProtectionPolicy.strict().trackingCategories.sumBy { it.id }
+        assertEquals(trackingStrictCategories, ContentBlocking.AT_STRICT)
+
+        val safeStrictBrowsingCategories = TrackingProtectionPolicy.strict().safeBrowsingCategories.sumBy { it.id }
+        assertEquals(safeStrictBrowsingCategories, ContentBlocking.SB_ALL)
         assertEquals(contentBlockingSettings.cookieBehavior, CookiePolicy.ACCEPT_NON_TRACKERS.id)
 
         try {
@@ -166,8 +158,7 @@ class GeckoEngineTest {
     fun defaultSettings() {
         val runtime = mock<GeckoRuntime>()
         val runtimeSettings = mock<GeckoRuntimeSettings>()
-        val contentBlockingSettings =
-                ContentBlocking.Settings.Builder().categories(TrackingProtectionPolicy.none().categories).build()
+        val contentBlockingSettings = ContentBlocking.Settings.Builder().build()
         whenever(runtimeSettings.javaScriptEnabled).thenReturn(true)
         whenever(runtime.settings).thenReturn(runtimeSettings)
         whenever(runtimeSettings.contentBlocking).thenReturn(contentBlockingSettings)
@@ -176,7 +167,7 @@ class GeckoEngineTest {
 
         val engine = GeckoEngine(context,
             DefaultSettings(
-                trackingProtectionPolicy = TrackingProtectionPolicy.all(),
+                trackingProtectionPolicy = TrackingProtectionPolicy.strict(),
                 javascriptEnabled = false,
                 webFontsEnabled = false,
                 automaticFontSizeAdjustment = false,
@@ -198,19 +189,12 @@ class GeckoEngineTest {
         verify(runtimeSettings).remoteDebuggingEnabled = true
         verify(runtimeSettings).autoplayDefault = GeckoRuntimeSettings.AUTOPLAY_DEFAULT_BLOCKED
 
-        assertEquals(TrackingProtectionPolicy.select(
-            TrackingProtectionPolicy.AD,
-            TrackingProtectionPolicy.SOCIAL,
-            TrackingProtectionPolicy.ANALYTICS,
-            TrackingProtectionPolicy.CONTENT,
-            TrackingProtectionPolicy.TEST,
-            TrackingProtectionPolicy.CRYPTOMINING,
-            TrackingProtectionPolicy.FINGERPRINTING,
-            TrackingProtectionPolicy.SAFE_BROWSING_HARMFUL,
-            TrackingProtectionPolicy.SAFE_BROWSING_UNWANTED,
-            TrackingProtectionPolicy.SAFE_BROWSING_MALWARE,
-            TrackingProtectionPolicy.SAFE_BROWSING_PHISHING
-        ).categories, contentBlockingSettings.categories)
+        val trackingStrictCategories = TrackingProtectionPolicy.strict().trackingCategories.sumBy { it.id }
+        assertEquals(trackingStrictCategories, ContentBlocking.AT_STRICT)
+
+        val safeStrictBrowsingCategories = TrackingProtectionPolicy.strict().safeBrowsingCategories.sumBy { it.id }
+        assertEquals(safeStrictBrowsingCategories, ContentBlocking.SB_ALL)
+
         assertEquals(contentBlockingSettings.cookieBehavior, CookiePolicy.ACCEPT_NON_TRACKERS.id)
         assertTrue(engine.settings.testingModeEnabled)
         assertEquals("test-ua", engine.settings.userAgentString)
@@ -220,7 +204,7 @@ class GeckoEngineTest {
 
         engine.settings.trackingProtectionPolicy =
             TrackingProtectionPolicy.select(
-                TrackingProtectionPolicy.AD,
+                trackingCategories = arrayOf(TrackingProtectionPolicy.TrackingCategory.AD),
                 cookiePolicy = CookiePolicy.ACCEPT_ONLY_FIRST_PARTY
             )
 

components/browser/engine-gecko-nightly/src/main/java/mozilla/components/browser/engine/gecko/GeckoEngine.kt

@@ -156,13 +156,14 @@ class GeckoEngine(
                 defaultSettings?.automaticLanguageAdjustment = value
             }
 
-        override var trackingProtectionPolicy: TrackingProtectionPolicy?
-            get() = TrackingProtectionPolicy.select(runtime.settings.contentBlocking.categories)
+        override var trackingProtectionPolicy: TrackingProtectionPolicy? = null
             set(value) {
-                value?.let {
-                    runtime.settings.contentBlocking.categories = it.categories
-                    runtime.settings.contentBlocking.cookieBehavior = it.cookiePolicy.id
+                value?.let { policy ->
+                    runtime.settings.contentBlocking.setAntiTracking(policy.trackingCategories.sumBy { it.id })
+                    runtime.settings.contentBlocking.setSafeBrowsing(policy.safeBrowsingCategories.sumBy { it.id })
+                    runtime.settings.contentBlocking.cookieBehavior = policy.cookiePolicy.id
                     defaultSettings?.trackingProtectionPolicy = value
+                    field = value
                 }
             }