Commit f7c7da1a authored by Arturo Mejia's avatar Arturo Mejia
Browse files

Closes #4098, #4110: Exposing new categories of content blocking.

parent 3a740b0f

buildSrc/src/main/java/Gecko.kt

+1 −1
Original line number Diff line number Diff line
@@ -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

+9 −5
Original line number Diff line number Diff line
@@ -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

+11 −7
Original line number Diff line number Diff line
@@ -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

+60 −21
Original line number Diff line number Diff line
@@ -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

+19 −35
Original line number Diff line number Diff line
@@ -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

            )