Top浏览器 v4.6.16 - AdblockWebView.java 源代码

package org.adblockplus.libadblockplus.android.webview;

import android.annotation.SuppressLint;
import android.annotation.TargetApi;
import android.content.Context;
import android.graphics.Bitmap;
import android.os.Bundle;
import android.text.TextUtils;
import android.util.AttributeSet;
import android.util.Pair;
import android.webkit.ConsoleMessage;
import android.webkit.JavascriptInterface;
import android.webkit.WebBackForwardList;
import android.webkit.WebChromeClient;
import android.webkit.WebResourceError;
import android.webkit.WebResourceRequest;
import android.webkit.WebResourceResponse;
import android.webkit.WebView;
import android.webkit.WebViewClient;
import java.io.IOException;
import java.net.MalformedURLException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Random;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicReference;
import java.util.concurrent.locks.ReentrantReadWriteLock;
import org.adblockplus.libadblockplus.FilterEngine;
import org.adblockplus.libadblockplus.HttpClient;
import org.adblockplus.libadblockplus.android.AdblockEngine;
import org.adblockplus.libadblockplus.android.AdblockEngineProvider;
import org.adblockplus.libadblockplus.android.SingleInstanceEngineProvider;
import org.adblockplus.libadblockplus.android.Utils;
import org.adblockplus.libadblockplus.android.webview.content_type.ContentTypeDetector;
import org.adblockplus.libadblockplus.android.webview.content_type.HeadersContentTypeDetector;
import org.adblockplus.libadblockplus.android.webview.content_type.OrderedContentTypeDetector;
import org.adblockplus.libadblockplus.android.webview.content_type.UrlFileExtensionTypeDetector;
import org.adblockplus.libadblockplus.sitekey.PublicKeyHolderImpl;
import org.adblockplus.libadblockplus.sitekey.SiteKeysConfiguration;
import q.a.a;

public class AdblockWebView extends WebView {
    private static final String ASSETS_CHARSET_NAME = "UTF-8";
    private static final String BRIDGE = "jsBridge";
    private static final String BRIDGE_TOKEN = "{{BRIDGE}}";
    private static final String DEBUG_TOKEN = "{{DEBUG}}";
    private static final String EMPTY_ELEMHIDE_ARRAY_STRING = "[]";
    private static final String EMPTY_ELEMHIDE_STRING = "";
    private static final String HIDDEN_TOKEN = "{{HIDDEN_FLAG}}";
    private static final String HIDE_TOKEN = "{{HIDE}}";
    private static final String SITEKEY_EXTRACTED_TOKEN = "{{SITEKEY_EXTRACTED_FLAG}}";
    private final AtomicReference<OptionalBoolean> adblockEnabled;
    private OrderedContentTypeDetector contentTypeDetector;
    private String elementsHiddenFlag;
    private String elemhideBlockedJs;
    private final AdblockEngineProvider.EngineCreatedListener engineCreatedCb;
    private final AdblockEngineProvider.EngineDisposedListener engineDisposedCb;
    private final AdblockEngine.SettingsChangedListener engineSettingsChangedCb;
    private final AtomicReference<EventsListener> eventsListenerAtomicReference;
    private String injectJs;
    private ProxyWebChromeClient intWebChromeClient;
    private ProxyWebViewClient intWebViewClient;
    private final AtomicBoolean jsInIframesEnabled;
    private Integer loadError;
    private boolean loading;
    private final AtomicReference<String> navigationUrl;
    private final AtomicReference<AdblockEngineProvider> providerReference;
    private SiteKeyExtractor siteKeyExtractor;
    private final AtomicReference<SiteKeysConfiguration> siteKeysConfiguration;
    private String sitekeyExtractedFlag;
    private final Map<String, String> url2Referrer;
    private final Map<String, Pair<String, String>> url2Stylesheets;

    public enum AbpShouldBlockResult {
        NOT_ENABLED,
        ALLOW_LOAD,
        ALLOW_LOAD_NO_SITEKEY_CHECK,
        BLOCK_LOAD
    }

    public class AdblockWebWebChromeClient extends ProxyWebChromeClient {
        public AdblockWebWebChromeClient(WebChromeClient webChromeClient) {
            super(webChromeClient);
        }

        @Override
        public boolean onConsoleMessage(ConsoleMessage consoleMessage) {
            a.a("JS: level=%s, message=\"%s\", sourceId=\"%s\", line=%d", new Object[]{consoleMessage.messageLevel(), consoleMessage.message(), consoleMessage.sourceId(), Integer.valueOf(consoleMessage.lineNumber())});
            return super.onConsoleMessage(consoleMessage);
        }

        @Override
        public void onProgressChanged(WebView webView, int i2) {
            a.a("onProgressChanged to %d%% for url: %s", new Object[]{Integer.valueOf(i2), webView.getUrl()});
            AdblockWebView.this.tryInjectJs();
            super.onProgressChanged(webView, i2);
        }
    }

    public class DisposeRunnable implements Runnable {
        private final Runnable disposeFinished;

        @Override
        public void run() {
            AdblockWebView.this.doDispose();
            Runnable runnable = this.disposeFinished;
            if (runnable != null) {
                runnable.run();
            }
        }

        private DisposeRunnable(Runnable runnable) {
            this.disposeFinished = runnable;
        }
    }

    public interface EventsListener {

        public enum AllowlistReason {
            DOCUMENT,
            DOMAIN,
            FILTER
        }

        public static final class AllowlistedResourceInfo extends ResourceInfo {
            private final AllowlistReason reason;

            public AllowlistedResourceInfo(String str, List<String> list, AllowlistReason allowlistReason) {
                super(str, list);
                this.reason = allowlistReason;
            }

            public AllowlistReason getReason() {
                return this.reason;
            }
        }

        public static final class BlockedResourceInfo extends ResourceInfo {
            private final FilterEngine.ContentType contentType;

            public BlockedResourceInfo(String str, List<String> list, FilterEngine.ContentType contentType) {
                super(str, list);
                this.contentType = contentType;
            }

            public FilterEngine.ContentType getContentType() {
                return this.contentType;
            }
        }

        public static class ResourceInfo {
            private final List<String> parentFrameUrls;
            private final String requestUrl;

            public ResourceInfo(String str, List<String> list) {
                this.requestUrl = str;
                this.parentFrameUrls = new ArrayList(list);
            }

            public List<String> getParentFrameUrls() {
                return this.parentFrameUrls;
            }

            public String getRequestUrl() {
                return this.requestUrl;
            }
        }

        void onNavigation();

        void onResourceLoadingAllowlisted(AllowlistedResourceInfo allowlistedResourceInfo);

        void onResourceLoadingBlocked(BlockedResourceInfo blockedResourceInfo);
    }

    public enum OptionalBoolean {
        UNDEFINED,
        TRUE,
        FALSE;

        public static OptionalBoolean from(boolean z) {
            return z ? TRUE : FALSE;
        }
    }

    public static class WebResponseResult {
        public static final WebResourceResponse ALLOW_LOAD = null;
        public static final String RESPONSE_CHARSET_NAME = "UTF-8";
        public static final String RESPONSE_MIME_TYPE = "text/plain";
        public static final WebResourceResponse BLOCK_LOAD = new WebResourceResponse(RESPONSE_MIME_TYPE, "UTF-8", null);
    }

    public AdblockWebView(Context context) {
        super(context);
        this.providerReference = new AtomicReference<>();
        this.url2Referrer = Collections.synchronizedMap(new HashMap());
        this.url2Stylesheets = Collections.synchronizedMap(new HashMap());
        this.navigationUrl = new AtomicReference<>();
        this.adblockEnabled = new AtomicReference<>(OptionalBoolean.UNDEFINED);
        this.eventsListenerAtomicReference = new AtomicReference<>();
        this.siteKeysConfiguration = new AtomicReference<>();
        this.jsInIframesEnabled = new AtomicBoolean(false);
        this.engineSettingsChangedCb = new AdblockEngine.SettingsChangedListener() {
            @Override
            public void onEnableStateChanged(boolean z) {
                OptionalBoolean from = OptionalBoolean.from(z);
                OptionalBoolean optionalBoolean = (OptionalBoolean) AdblockWebView.this.adblockEnabled.getAndSet(from);
                if (optionalBoolean == OptionalBoolean.UNDEFINED || optionalBoolean == from) {
                    return;
                }
                a.a("Filter Engine status changed, enable status is %s", new Object[]{from});
                AdblockWebView.this.post(new Runnable() {
                    @Override
                    public void run() {
                        AdblockWebView.this.clearCache(true);
                    }
                });
            }
        };
        this.engineCreatedCb = new AdblockEngineProvider.EngineCreatedListener() {
            @Override
            public void onAdblockEngineCreated(AdblockEngine adblockEngine) {
                AdblockWebView.this.adblockEnabled.set(OptionalBoolean.from(adblockEngine.isEnabled()));
                a.a("Filter Engine created, enable status is %s", new Object[]{AdblockWebView.this.adblockEnabled.get()});
                adblockEngine.addSettingsChangedListener(AdblockWebView.this.engineSettingsChangedCb);
            }
        };
        this.engineDisposedCb = new AdblockEngineProvider.EngineDisposedListener() {
            @Override
            public void onAdblockEngineDisposed() {
                AdblockWebView.this.adblockEnabled.set(OptionalBoolean.UNDEFINED);
            }
        };
        initAbp();
    }

    public List<String> buildFramesHierarchy(String str) {
        ArrayList arrayList = new ArrayList();
        String str2 = str;
        while (true) {
            str2 = this.url2Referrer.get(str2);
            if (str2 == null) {
                break;
            }
            if (arrayList.contains(str2)) {
                a.g("Detected referrer loop, finished creating referrers list", new Object[0]);
                break;
            }
            arrayList.add(str2);
        }
        String str3 = this.navigationUrl.get();
        if (TextUtils.isEmpty(str3)) {
            return arrayList;
        }
        String domain = Utils.getDomain(str3);
        if (TextUtils.isEmpty(domain)) {
            a.b("buildFramesHierarchy() failed to obtain a domain from url " + str3, new Object[0]);
            return arrayList;
        }
        boolean z = (arrayList.isEmpty() || domain.equals(Utils.getDomain((String) arrayList.get(arrayList.size() - 1)))) ? false : true;
        if (arrayList.isEmpty() || z) {
            a.a("Adding top level referrer `%s` for `%s`", new Object[]{str3, str});
            arrayList.add(str3);
        }
        return arrayList;
    }

    private void buildInjectJs() {
        try {
            if (this.injectJs == null) {
                StringBuffer stringBuffer = new StringBuffer();
                stringBuffer.append(readScriptFile("inject.js").replace(HIDE_TOKEN, readScriptFile("css.js")));
                stringBuffer.append(readScriptFile("elemhideemu.js"));
                this.injectJs = stringBuffer.toString();
            }
            if (this.elemhideBlockedJs == null) {
                this.elemhideBlockedJs = readScriptFile("elemhideblocked.js");
            }
        } catch (IOException e2) {
            a.d(e2, "Failed to read script", new Object[0]);
        }
    }

    public void clearReferrers() {
        a.a("Clearing referrers", new Object[0]);
        this.url2Referrer.clear();
    }

    public void clearStylesheets() {
        a.a("Clearing stylesheet", new Object[0]);
        this.url2Stylesheets.clear();
    }

    public void doDispose() {
        a.g("Disposing AdblockEngine", new Object[0]);
        getProvider().release();
    }

    public void elemhideBlockedResource(final String str) {
        try {
            String extractPathWithQuery = Utils.extractPathWithQuery(str);
            if (extractPathWithQuery.startsWith("/")) {
                extractPathWithQuery = extractPathWithQuery.substring(1);
            }
            a.a("Trying to elemhide visible blocked resource with url `%s` and path `%s`", new Object[]{str, extractPathWithQuery});
            final StringBuilder sb = new StringBuilder();
            sb.append("[src$='");
            sb.append(extractPathWithQuery);
            sb.append("'], [srcset$='");
            sb.append(extractPathWithQuery);
            sb.append("']");
            post(new Runnable() {
                @Override
                public void run() {
                    AdblockWebView.this.evaluateJavascript(AdblockWebView.this.elemhideBlockedJs + "\n\nelemhideForSelector(\"" + str + "\", \"" + Utils.escapeJavaScriptString(sb.toString()) + "\", 0)", null);
                }
            });
        } catch (MalformedURLException unused) {
            a.b("Failed to parse URI for blocked resource:" + str + ". Skipping element hiding", new Object[0]);
        }
    }

    public ContentTypeDetector ensureContentTypeDetectorCreatedAndGet() {
        if (this.contentTypeDetector == null) {
            this.contentTypeDetector = new OrderedContentTypeDetector(new HeadersContentTypeDetector(), new UrlFileExtensionTypeDetector());
        }
        return this.contentTypeDetector;
    }

    private void ensureProvider() {
        if (getProvider() == null) {
            setProvider(new SingleInstanceEngineProvider(AdblockEngine.builder(getContext(), AdblockEngine.BASE_PATH_DIRECTORY)));
        }
    }

    private EventsListener getEventsListener() {
        return this.eventsListenerAtomicReference.get();
    }

    public AdblockEngineProvider getProvider() {
        return this.providerReference.get();
    }

    private Pair<String, String> getStylesheetsForUrl(String str) {
        return this.url2Stylesheets.get(Utils.getUrlWithoutFragment(str));
    }

    @SuppressLint({"SetJavaScriptEnabled"})
    private void initAbp() {
        addJavascriptInterface(this, BRIDGE);
        initRandom();
        buildInjectJs();
        getSettings().setJavaScriptEnabled(true);
        this.siteKeyExtractor = new CombinedSiteKeyExtractor(this);
        this.intWebChromeClient = new AdblockWebWebChromeClient(null);
        this.intWebViewClient = new AdblockWebViewClient(null);
        super.setWebChromeClient(this.intWebChromeClient);
        super.setWebViewClient(this.intWebViewClient);
    }

    private void initRandom() {
        Random random = new Random();
        this.elementsHiddenFlag = "abp" + Math.abs(random.nextLong());
        this.sitekeyExtractedFlag = "abp" + Math.abs(random.nextLong());
    }

    public boolean isVisibleResource(FilterEngine.ContentType contentType) {
        return contentType == FilterEngine.ContentType.IMAGE || contentType == FilterEngine.ContentType.MEDIA || contentType == FilterEngine.ContentType.OBJECT || contentType == FilterEngine.ContentType.SUBDOCUMENT;
    }

    private void loadUrlCommon() {
        ensureProvider();
        if (this.loading) {
            stopAbpLoading();
        }
        this.siteKeyExtractor.startNewPage();
    }

    public void notifyNavigation() {
        EventsListener eventsListener = getEventsListener();
        if (eventsListener != null) {
            eventsListener.onNavigation();
        }
    }

    public void notifyResourceAllowlisted(EventsListener.AllowlistedResourceInfo allowlistedResourceInfo) {
        EventsListener eventsListener = getEventsListener();
        if (eventsListener != null) {
            eventsListener.onResourceLoadingAllowlisted(allowlistedResourceInfo);
        }
    }

    public void notifyResourceBlocked(EventsListener.BlockedResourceInfo blockedResourceInfo) {
        EventsListener eventsListener = getEventsListener();
        if (eventsListener != null) {
            eventsListener.onResourceLoadingBlocked(blockedResourceInfo);
        }
    }

    private String readScriptFile(String str) {
        return Utils.readAssetAsString(getContext(), str, "UTF-8").replace(BRIDGE_TOKEN, BRIDGE).replace(DEBUG_TOKEN, "//").replace(HIDDEN_TOKEN, this.elementsHiddenFlag).replace(SITEKEY_EXTRACTED_TOKEN, this.sitekeyExtractedFlag);
    }

    private void runScript(String str) {
        a.a("runScript started", new Object[0]);
        evaluateJavascript(str, null);
        a.a("runScript finished", new Object[0]);
    }

    public void startAbpLoading(String str) {
        a.a("Start loading %s", new Object[]{str});
        this.loading = true;
        this.loadError = null;
        if (str != null) {
            String urlWithoutFragment = Utils.getUrlWithoutFragment(str);
            if (this.navigationUrl.compareAndSet(null, urlWithoutFragment)) {
                generateStylesheetForUrl(urlWithoutFragment, true);
            }
        }
    }

    public void stopAbpLoading() {
        a.a("Stop abp loading", new Object[0]);
        this.loading = false;
        clearReferrers();
    }

    public void tryInjectJs() {
        if (this.adblockEnabled.get() == OptionalBoolean.TRUE && this.loadError == null && this.injectJs != null) {
            a.a("Injecting script", new Object[0]);
            runScript(this.injectJs);
        }
    }

    public void dispose(Runnable runnable) {
        a.a("Dispose invoked", new Object[0]);
        if (getProvider() == null) {
            a.a("No internal AdblockEngineProvider created", new Object[0]);
            return;
        }
        ReentrantReadWriteLock.ReadLock readEngineLock = getProvider().getReadEngineLock();
        readEngineLock.lock();
        try {
            AdblockEngine engine = getProvider().getEngine();
            if (engine != null) {
                engine.removeSettingsChangedListener(this.engineSettingsChangedCb);
            }
            getProvider().removeEngineCreatedListener(this.engineCreatedCb);
            getProvider().removeEngineDisposedListener(this.engineDisposedCb);
            readEngineLock.unlock();
            stopLoading();
            new DisposeRunnable(runnable).run();
        } catch (Throwable th) {
            readEngineLock.unlock();
            throw th;
        }
    }

    public void enableJsInIframes(boolean z) {
        if (z && getSiteKeysConfiguration() == null) {
            throw new IllegalStateException("Site Keys configuration must be set (enabled) to use this feature!");
        }
        this.jsInIframesEnabled.set(z);
    }

    public boolean generateStylesheetForUrl(String str, boolean z) {
        String str2;
        boolean z2;
        String str3;
        boolean jsInIframesEnabled = getJsInIframesEnabled();
        a.a("generateStylesheetForUrl() called for url %s, isMainFrame = %b, isJsInIframesEnabled == %b", new Object[]{str, Boolean.valueOf(z), Boolean.valueOf(jsInIframesEnabled)});
        if (!z && !jsInIframesEnabled) {
            return false;
        }
        String domain = Utils.getDomain(str);
        if (TextUtils.isEmpty(domain)) {
            a.b("Failed to extract domain from %s", new Object[]{str});
            return false;
        }
        Pair<String, String> pair = this.url2Stylesheets.get(str);
        if (pair != null) {
            return (((String) pair.first).equals("") && ((String) pair.second).equals(EMPTY_ELEMHIDE_ARRAY_STRING)) ? false : true;
        }
        ReentrantReadWriteLock.ReadLock readEngineLock = getProvider().getReadEngineLock();
        readEngineLock.lock();
        try {
            if (getProvider().getCounter() != 0) {
                readEngineLock.unlock();
                getProvider().waitForReady();
                readEngineLock.lock();
                if (getProvider().getCounter() != 0) {
                    z2 = false;
                    if (!z2 || getProvider().getEngine() == null) {
                        str3 = EMPTY_ELEMHIDE_ARRAY_STRING;
                        str2 = "";
                    } else {
                        FilterEngine filterEngine = getProvider().getEngine().getFilterEngine();
                        a.a("Requesting elemhide selectors from AdblockEngine for %s", new Object[]{domain});
                        List<String> arrayList = z ? new ArrayList<>() : buildFramesHierarchy(str);
                        arrayList.add(0, str);
                        SiteKeysConfiguration siteKeysConfiguration = getSiteKeysConfiguration();
                        String stripPadding = siteKeysConfiguration != null ? PublicKeyHolderImpl.stripPadding(siteKeysConfiguration.getPublicKeyHolder().getAny(arrayList, "")) : null;
                        if (!z && siteKeysConfiguration != null && stripPadding.isEmpty()) {
                            a.a("Waiting for a site key when handling %s", new Object[]{str});
                            if (this.siteKeyExtractor.waitForSitekeyCheck(str, z)) {
                                stripPadding = PublicKeyHolderImpl.stripPadding(siteKeysConfiguration.getPublicKeyHolder().getAny(arrayList, ""));
                            }
                        }
                        String str4 = stripPadding;
                        boolean isContentAllowlisted = filterEngine.isContentAllowlisted(str, FilterEngine.ContentType.maskOf(FilterEngine.ContentType.GENERICHIDE), arrayList, str4);
                        str2 = getProvider().getEngine().getElementHidingStyleSheet(str, domain, arrayList, str4, isContentAllowlisted);
                        try {
                            StringBuilder sb = new StringBuilder();
                            sb.append("Finished requesting elemhide stylesheet, got %d symbols");
                            sb.append(isContentAllowlisted ? " (specificOnly)" : "");
                            sb.append(" for %s");
                            a.a(sb.toString(), new Object[]{Integer.valueOf(str2.length()), domain});
                            a.a("Requesting elemhideemu selectors from AdblockEngine for %s", new Object[]{domain});
                            List<FilterEngine.EmulationSelector> elementHidingEmulationSelectors = getProvider().getEngine().getElementHidingEmulationSelectors(str, domain, arrayList, str4);
                            a.a("Finished requesting elemhideemu selectors, got %d symbols for %s", new Object[]{Integer.valueOf(elementHidingEmulationSelectors.size()), domain});
                            str3 = Utils.emulationSelectorListToJsonArray(elementHidingEmulationSelectors);
                        } catch (Throwable unused) {
                            readEngineLock.unlock();
                            this.url2Stylesheets.put(str, new Pair<>(str2, EMPTY_ELEMHIDE_ARRAY_STRING));
                            return !str2.equals("");
                        }
                    }
                    readEngineLock.unlock();
                    this.url2Stylesheets.put(str, new Pair<>(str2, str3));
                    return str2.equals("") || !str3.equals(EMPTY_ELEMHIDE_ARRAY_STRING);
                }
            }
            z2 = true;
            if (z2) {
            }
            str3 = EMPTY_ELEMHIDE_ARRAY_STRING;
            str2 = "";
            readEngineLock.unlock();
            this.url2Stylesheets.put(str, new Pair<>(str2, str3));
            if (str2.equals("")) {
            }
        } catch (Throwable unused2) {
            str2 = "";
        }
    }

    @JavascriptInterface
    public String getElemhideEmulationSelectors(String str) {
        Pair<String, String> stylesheetsForUrl = getStylesheetsForUrl(str);
        if (stylesheetsForUrl == null) {
            return EMPTY_ELEMHIDE_ARRAY_STRING;
        }
        a.a("Elemhideemu selectors for `%s`, %d bytes", new Object[]{str, Integer.valueOf(((String) stylesheetsForUrl.second).length())});
        return (String) stylesheetsForUrl.second;
    }

    @JavascriptInterface
    public String getElemhideStyleSheet(String str) {
        Pair<String, String> stylesheetsForUrl = getStylesheetsForUrl(str);
        if (stylesheetsForUrl == null) {
            return "";
        }
        a.a("Elemhide selectors for `%s`, %d bytes", new Object[]{str, Integer.valueOf(((String) stylesheetsForUrl.first).length())});
        return (String) stylesheetsForUrl.first;
    }

    public String getInjectJs() {
        return this.injectJs;
    }

    public boolean getJsInIframesEnabled() {
        return this.jsInIframesEnabled.get() && getSiteKeysConfiguration() != null;
    }

    public String getNavigationUrl() {
        return this.navigationUrl.get();
    }

    public SiteKeyExtractor getSiteKeyExtractor() {
        return this.siteKeyExtractor;
    }

    public SiteKeysConfiguration getSiteKeysConfiguration() {
        return this.siteKeysConfiguration.get();
    }

    @Override
    public void goBack() {
        if (this.loading) {
            stopAbpLoading();
        }
        if (canGoBack()) {
            this.navigationUrl.set(null);
            this.siteKeyExtractor.startNewPage();
        }
        super.goBack();
    }

    @Override
    public void goForward() {
        if (this.loading) {
            stopAbpLoading();
        }
        if (canGoForward()) {
            this.navigationUrl.set(null);
            this.siteKeyExtractor.startNewPage();
        }
        super.goForward();
    }

    @Override
    public void loadData(String str, String str2, String str3) {
        loadUrlCommon();
        super.loadData(str, str2, str3);
    }

    @Override
    public void loadDataWithBaseURL(String str, String str2, String str3, String str4, String str5) {
        loadUrlCommon();
        super.loadDataWithBaseURL(str, str2, str3, str4, str5);
    }

    @Override
    public void loadUrl(String str) {
        loadUrlCommon();
        super.loadUrl(str);
    }

    @Override
    public void reload() {
        ensureProvider();
        if (this.loading) {
            stopAbpLoading();
        }
        super.reload();
    }

    @Override
    public WebBackForwardList restoreState(Bundle bundle) {
        this.siteKeyExtractor.startNewPage();
        return super.restoreState(bundle);
    }

    public void setEventsListener(EventsListener eventsListener) {
        this.eventsListenerAtomicReference.set(eventsListener);
    }

    public void setProvider(final AdblockEngineProvider adblockEngineProvider) {
        if (adblockEngineProvider == null) {
            throw new IllegalArgumentException("Provider cannot be null");
        }
        if (getProvider() == adblockEngineProvider) {
            return;
        }
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                AdblockWebView.this.providerReference.set(adblockEngineProvider);
                ReentrantReadWriteLock.ReadLock readEngineLock = adblockEngineProvider.getReadEngineLock();
                boolean tryLock = readEngineLock.tryLock();
                try {
                    AdblockWebView.this.getProvider().retain(true);
                    if (!tryLock || AdblockWebView.this.getProvider().getEngine() == null) {
                        AdblockWebView.this.getProvider().addEngineCreatedListener(AdblockWebView.this.engineCreatedCb);
                        AdblockWebView.this.getProvider().addEngineDisposedListener(AdblockWebView.this.engineDisposedCb);
                    } else {
                        AdblockWebView.this.adblockEnabled.set(OptionalBoolean.from(AdblockWebView.this.getProvider().getEngine().isEnabled()));
                        a.a("Filter Engine already created, enable status is %s", new Object[]{AdblockWebView.this.adblockEnabled});
                        AdblockWebView.this.getProvider().getEngine().addSettingsChangedListener(AdblockWebView.this.engineSettingsChangedCb);
                    }
                } finally {
                    if (tryLock) {
                        readEngineLock.unlock();
                    }
                }
            }
        };
        if (getProvider() != null) {
            dispose(runnable);
        } else {
            runnable.run();
        }
    }

    public void setSiteKeyExtractor(SiteKeyExtractor siteKeyExtractor) {
        this.siteKeyExtractor = siteKeyExtractor;
    }

    public void setSiteKeysConfiguration(SiteKeysConfiguration siteKeysConfiguration) {
        this.siteKeysConfiguration.set(siteKeysConfiguration);
        this.siteKeyExtractor.setSiteKeysConfiguration(siteKeysConfiguration);
    }

    @Override
    public void setWebChromeClient(WebChromeClient webChromeClient) {
        this.intWebChromeClient.setExtWebChromeClient(webChromeClient);
    }

    @Override
    public void setWebViewClient(WebViewClient webViewClient) {
        this.intWebViewClient.setExtWebViewClient(webViewClient);
    }

    @Override
    public void stopLoading() {
        stopAbpLoading();
        super.stopLoading();
    }

    public class AdblockWebViewClient extends ProxyWebViewClient {
        public AdblockWebViewClient(WebViewClient webViewClient) {
            super(webViewClient);
        }

        private String getFirstParent(List<String> list) {
            return (list == null || list.size() == 0) ? "" : list.get(0);
        }

        private AbpShouldBlockResult notifyAndReturnBlockingResponse(String str, List<String> list, FilterEngine.ContentType contentType) {
            if (AdblockWebView.this.isVisibleResource(contentType)) {
                AdblockWebView.this.elemhideBlockedResource(str);
            }
            AdblockWebView.this.notifyResourceBlocked(new EventsListener.BlockedResourceInfo(str, list, contentType));
            return AbpShouldBlockResult.BLOCK_LOAD;
        }

        private org.adblockplus.libadblockplus.android.webview.AdblockWebView.AbpShouldBlockResult shouldAbpBlockRequest(android.webkit.WebResourceRequest r31) {
            throw new UnsupportedOperationException("Method not decompiled: org.adblockplus.libadblockplus.android.webview.AdblockWebView.AdblockWebViewClient.shouldAbpBlockRequest(android.webkit.WebResourceRequest):org.adblockplus.libadblockplus.android.webview.AdblockWebView$AbpShouldBlockResult");
        }

        @Override
        public void onPageFinished(WebView webView, String str) {
            a.a("onPageFinished called for url %s", new Object[]{str});
            AdblockWebView.this.loading = false;
            super.onPageFinished(webView, str);
        }

        @Override
        public void onPageStarted(WebView webView, String str, Bitmap bitmap) {
            a.a("onPageStarted called for url %s", new Object[]{str});
            if (AdblockWebView.this.loading) {
                AdblockWebView.this.stopAbpLoading();
            }
            AdblockWebView.this.startAbpLoading(str);
            AdblockWebView.this.notifyNavigation();
            super.onPageStarted(webView, str, bitmap);
        }

        @Override
        public void onReceivedError(WebView webView, int i2, String str, String str2) {
            a.b("onReceivedError: code=%d with description=%s for url=%s", new Object[]{Integer.valueOf(i2), str, str2});
            AdblockWebView.this.loadError = Integer.valueOf(i2);
            super.onReceivedError(webView, i2, str, str2);
        }

        @Override
        @TargetApi(21)
        public WebResourceResponse shouldInterceptRequest(WebView webView, WebResourceRequest webResourceRequest) {
            WebResourceResponse shouldInterceptRequest;
            if (webResourceRequest.isForMainFrame()) {
                a.a("Updating navigationUrl to `%s`", new Object[]{webResourceRequest.getUrl().toString()});
                AdblockWebView.this.navigationUrl.set(Utils.getUrlWithoutFragment(webResourceRequest.getUrl().toString()));
            }
            AbpShouldBlockResult shouldAbpBlockRequest = shouldAbpBlockRequest(webResourceRequest);
            if (AbpShouldBlockResult.NOT_ENABLED.equals(shouldAbpBlockRequest)) {
                AdblockWebView.this.clearStylesheets();
                return WebResponseResult.ALLOW_LOAD;
            }
            if (AbpShouldBlockResult.BLOCK_LOAD.equals(shouldAbpBlockRequest)) {
                return WebResponseResult.BLOCK_LOAD;
            }
            Map<String, String> requestHeaders = webResourceRequest.getRequestHeaders();
            String uri = webResourceRequest.getUrl().toString();
            WebViewClient extWebViewClient = getExtWebViewClient();
            if (extWebViewClient == null || (shouldInterceptRequest = extWebViewClient.shouldInterceptRequest(webView, webResourceRequest)) == null) {
                if (AbpShouldBlockResult.ALLOW_LOAD_NO_SITEKEY_CHECK.equals(shouldAbpBlockRequest)) {
                    return WebResponseResult.ALLOW_LOAD;
                }
                if (!requestHeaders.containsKey(HttpClient.HEADER_REQUESTED_RANGE)) {
                    return AdblockWebView.this.siteKeyExtractor.extract(webResourceRequest);
                }
                a.a("Skipping site key check for the request with a Range header", new Object[0]);
                return WebResponseResult.ALLOW_LOAD;
            }
            if (AbpShouldBlockResult.ALLOW_LOAD_NO_SITEKEY_CHECK.equals(shouldAbpBlockRequest)) {
                a.a("Skipped verifying of the site keys with external shouldInterceptRequest response", new Object[0]);
            } else {
                a.a("Verifying site keys with external shouldInterceptRequest response", new Object[0]);
                AdblockWebView.this.getSiteKeysConfiguration().getSiteKeyVerifier().verifyInHeaders(uri, requestHeaders, shouldInterceptRequest.getResponseHeaders());
                a.a("Finished verifying, returning external response and stop", new Object[0]);
            }
            return shouldInterceptRequest;
        }

        @Override
        public boolean shouldOverrideUrlLoading(WebView webView, WebResourceRequest webResourceRequest) {
            a.a("shouldOverrideUrlLoading called for view.getUrl() %s", new Object[]{webView.getUrl()});
            AdblockWebView.this.clearReferrers();
            return super.shouldOverrideUrlLoading(webView, webResourceRequest);
        }

        @Override
        public boolean shouldOverrideUrlLoading(WebView webView, String str) {
            a.a("shouldOverrideUrlLoading called for url %s", new Object[]{str});
            AdblockWebView.this.clearReferrers();
            return super.shouldOverrideUrlLoading(webView, str);
        }

        @Override
        @TargetApi(23)
        public void onReceivedError(WebView webView, WebResourceRequest webResourceRequest, WebResourceError webResourceError) {
            a.b("onReceivedError: code=%d with description=%s for url=%s request.isForMainFrame()=%s", new Object[]{Integer.valueOf(webResourceError.getErrorCode()), webResourceError.getDescription(), webResourceRequest.getUrl(), Boolean.valueOf(webResourceRequest.isForMainFrame())});
            super.onReceivedError(webView, webResourceRequest, webResourceError);
        }
    }

    @Override
    public void loadUrl(String str, Map<String, String> map) {
        loadUrlCommon();
        super.loadUrl(str, map);
    }

    public AdblockWebView(Context context, AttributeSet attributeSet) {
        super(context, attributeSet);
        this.providerReference = new AtomicReference<>();
        this.url2Referrer = Collections.synchronizedMap(new HashMap());
        this.url2Stylesheets = Collections.synchronizedMap(new HashMap());
        this.navigationUrl = new AtomicReference<>();
        this.adblockEnabled = new AtomicReference<>(OptionalBoolean.UNDEFINED);
        this.eventsListenerAtomicReference = new AtomicReference<>();
        this.siteKeysConfiguration = new AtomicReference<>();
        this.jsInIframesEnabled = new AtomicBoolean(false);
        this.engineSettingsChangedCb = new AdblockEngine.SettingsChangedListener() {
            @Override
            public void onEnableStateChanged(boolean z) {
                OptionalBoolean from = OptionalBoolean.from(z);
                OptionalBoolean optionalBoolean = (OptionalBoolean) AdblockWebView.this.adblockEnabled.getAndSet(from);
                if (optionalBoolean == OptionalBoolean.UNDEFINED || optionalBoolean == from) {
                    return;
                }
                a.a("Filter Engine status changed, enable status is %s", new Object[]{from});
                AdblockWebView.this.post(new Runnable() {
                    @Override
                    public void run() {
                        AdblockWebView.this.clearCache(true);
                    }
                });
            }
        };
        this.engineCreatedCb = new AdblockEngineProvider.EngineCreatedListener() {
            @Override
            public void onAdblockEngineCreated(AdblockEngine adblockEngine) {
                AdblockWebView.this.adblockEnabled.set(OptionalBoolean.from(adblockEngine.isEnabled()));
                a.a("Filter Engine created, enable status is %s", new Object[]{AdblockWebView.this.adblockEnabled.get()});
                adblockEngine.addSettingsChangedListener(AdblockWebView.this.engineSettingsChangedCb);
            }
        };
        this.engineDisposedCb = new AdblockEngineProvider.EngineDisposedListener() {
            @Override
            public void onAdblockEngineDisposed() {
                AdblockWebView.this.adblockEnabled.set(OptionalBoolean.UNDEFINED);
            }
        };
        initAbp();
    }

    public AdblockWebView(Context context, AttributeSet attributeSet, int i2) {
        super(context, attributeSet, i2);
        this.providerReference = new AtomicReference<>();
        this.url2Referrer = Collections.synchronizedMap(new HashMap());
        this.url2Stylesheets = Collections.synchronizedMap(new HashMap());
        this.navigationUrl = new AtomicReference<>();
        this.adblockEnabled = new AtomicReference<>(OptionalBoolean.UNDEFINED);
        this.eventsListenerAtomicReference = new AtomicReference<>();
        this.siteKeysConfiguration = new AtomicReference<>();
        this.jsInIframesEnabled = new AtomicBoolean(false);
        this.engineSettingsChangedCb = new AdblockEngine.SettingsChangedListener() {
            @Override
            public void onEnableStateChanged(boolean z) {
                OptionalBoolean from = OptionalBoolean.from(z);
                OptionalBoolean optionalBoolean = (OptionalBoolean) AdblockWebView.this.adblockEnabled.getAndSet(from);
                if (optionalBoolean == OptionalBoolean.UNDEFINED || optionalBoolean == from) {
                    return;
                }
                a.a("Filter Engine status changed, enable status is %s", new Object[]{from});
                AdblockWebView.this.post(new Runnable() {
                    @Override
                    public void run() {
                        AdblockWebView.this.clearCache(true);
                    }
                });
            }
        };
        this.engineCreatedCb = new AdblockEngineProvider.EngineCreatedListener() {
            @Override
            public void onAdblockEngineCreated(AdblockEngine adblockEngine) {
                AdblockWebView.this.adblockEnabled.set(OptionalBoolean.from(adblockEngine.isEnabled()));
                a.a("Filter Engine created, enable status is %s", new Object[]{AdblockWebView.this.adblockEnabled.get()});
                adblockEngine.addSettingsChangedListener(AdblockWebView.this.engineSettingsChangedCb);
            }
        };
        this.engineDisposedCb = new AdblockEngineProvider.EngineDisposedListener() {
            @Override
            public void onAdblockEngineDisposed() {
                AdblockWebView.this.adblockEnabled.set(OptionalBoolean.UNDEFINED);
            }
        };
        initAbp();
    }
}