Issue 6265 - Create shared AdblockEngine instance in AdblockWebView in background

libadblockplus-android-webview/src/org/adblockplus/libadblockplus/android/webview/AdblockWebView.java

 /*
  * This file is part of Adblock Plus <https://adblockplus.org/>,
  * Copyright (C) 2006-present eyeo GmbH
  *
  * Adblock Plus is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 3 as
  * published by the Free Software Foundation.
  *
  * Adblock Plus is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ skipping 31 matching lines @@
 import android.webkit.WebResourceRequest;  // makes android min version to be 21
 import android.webkit.WebResourceResponse;
 import android.webkit.WebStorage;
 import android.webkit.WebView;
 import android.webkit.WebViewClient;
 
 import org.adblockplus.libadblockplus.FilterEngine;
 import org.adblockplus.libadblockplus.Subscription;
 import org.adblockplus.libadblockplus.android.AdblockEngine;
 import org.adblockplus.libadblockplus.android.AdblockEngineProvider;
-import org.adblockplus.libadblockplus.android.SingletonEngineProvider;
+import org.adblockplus.libadblockplus.android.SingleInstanceEngineProvider;
 import org.adblockplus.libadblockplus.android.Utils;
 
 import java.io.IOException;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.regex.Pattern;
@@ skipping 27 matching lines @@
 
   private static final Pattern RE_JS = Pattern.compile("\\.js$", Pattern.CASE_INSENSITIVE);
   private static final Pattern RE_CSS = Pattern.compile("\\.css$", Pattern.CASE_INSENSITIVE);
   private static final Pattern RE_IMAGE = Pattern.compile("\\.(?:gif|png|jpe?g|bmp|ico)$", Pattern.CASE_INSENSITIVE);
   private static final Pattern RE_FONT = Pattern.compile("\\.(?:ttf|woff)$", Pattern.CASE_INSENSITIVE);
   private static final Pattern RE_HTML = Pattern.compile("\\.html?$", Pattern.CASE_INSENSITIVE);
 
   private volatile boolean addDomListener = true;
   private boolean adblockEnabled = true;
   private boolean debugMode;
-  private AdblockEngineProvider adblockEngineProvider;
+  private AdblockEngineProvider provider;
   private Integer loadError;
   private int allowDrawDelay = ALLOW_DRAW_DELAY;
   private WebChromeClient extWebChromeClient;
   private WebViewClient extWebViewClient;
   private WebViewClient intWebViewClient;
   private Map<String, String> url2Referrer = Collections.synchronizedMap(new HashMap<String, String>());
   private String url;
   private String domain;
   private String injectJs;
   private CountDownLatch elemHideLatch;
@@ skipping 116 matching lines @@
       .replace(DEBUG_TOKEN, (debugMode ? "" : "//"));
   }
 
   private void runScript(String script)
   {
     d("runScript started");
     evaluateJavascript(script, null);
     d("runScript finished");
   }
 
-  public void setAdblockEngineProvider(final AdblockEngineProvider adblockEngineProvider)
+  public void setProvider(final AdblockEngineProvider provider)
   {
-    if (this.adblockEngineProvider != null && adblockEngineProvider != null && this.adblockEngineProvider == adblockEngineProvider)
+    if (this.provider != null && provider != null && this.provider == provider)
     {
       return;
     }
 
     final Runnable setRunnable = new Runnable()
     {
       @Override
       public void run()
       {
-        AdblockWebView.this.adblockEngineProvider = adblockEngineProvider;
-        AdblockWebView.this.adblockEngineProvider.retain(true); // asynchronously
+        AdblockWebView.this.provider = provider;
+        AdblockWebView.this.provider.retain(true); // asynchronously
       }
     };
 
-    if (this.adblockEngineProvider != null)
+    if (this.provider != null)
     {
       // as adblockEngine can be busy with elemhide thread we need to use callback
       this.dispose(setRunnable);
     }
     else
     {
       setRunnable.run();
     }
   }
 
@@ skipping 545 matching lines @@
       {
         super.onReceivedLoginRequest(view, realm, account, args);
       }
     }
 
     protected WebResourceResponse shouldInterceptRequest(
       WebView webview, String url, boolean isMainFrame,
       boolean isXmlHttpRequest, String[] referrerChainArray)
     {
       // if dispose() was invoke, but the page is still loading then just let it go
-      if (adblockEngineProvider.getAdblockEngine() == null)
+      if (provider.getCounter() == 0)
       {
         e("FilterEngine already disposed, allow loading");
 
         // allow loading by returning null
         return null;
       }
 
       if (isMainFrame)
       {
         // never blocking main frame requests, just subrequests
         w(url + " is main frame, allow loading");
 
         // allow loading by returning null
         return null;
       }
 
       // whitelisted
-      if (adblockEngineProvider.getAdblockEngine().isDomainWhitelisted(url, referrerChainArray))
+      if (provider.getEngine().isDomainWhitelisted(url, referrerChainArray))
       {
         w(url + " domain is whitelisted, allow loading");
 
         // allow loading by returning null
         return null;
       }
 
-      if (adblockEngineProvider.getAdblockEngine().isDocumentWhitelisted(url, referrerChainArray))
+      if (provider.getEngine().isDocumentWhitelisted(url, referrerChainArray))
       {
         w(url + " document is whitelisted, allow loading");
 
         // allow loading by returning null
         return null;
       }
 
       // determine the content
       FilterEngine.ContentType contentType;
       if (isXmlHttpRequest)
@@ skipping 22 matching lines @@
         {
           contentType = FilterEngine.ContentType.SUBDOCUMENT;
         }
         else
         {
           contentType = FilterEngine.ContentType.OTHER;
         }
       }
 
       // check if we should block
-      if (adblockEngineProvider.getAdblockEngine().matches(url, contentType, referrerChainArray))
+      if (provider.getEngine().matches(url, contentType, referrerChainArray))
       {
         w("Blocked loading " + url);
 
         // if we should block, return empty response which results in 'errorLoading' callback
         return new WebResourceResponse("text/plain", "UTF-8", null);
       }
 
       d("Allowed loading " + url);
 
       // continue by returning null
@@ skipping 58 matching lines @@
     {
       this.finishedLatch = finishedLatch;
       isCancelled = new AtomicBoolean(false);
     }
 
     @Override
     public void run()
     {
       try
       {
-        if (adblockEngineProvider.getAdblockEngine() == null)
+        if (provider.getCounter() == 0)
         {
           w("FilterEngine already disposed");
           selectorsString = EMPTY_ELEMHIDE_ARRAY_STRING;
         }
         else
         {
           String[] referrers = new String[]
             {
               url
             };
 
-          List<Subscription> subscriptions = adblockEngineProvider
-            .getAdblockEngine()
+          List<Subscription> subscriptions = provider
+            .getEngine()
             .getFilterEngine()
             .getListedSubscriptions();
 
           try
           {
             d("Listed subscriptions: " + subscriptions.size());
             if (debugMode)
             {
               for (Subscription eachSubscription : subscriptions)
               {
                 d("Subscribed to "
                   + (eachSubscription.isDisabled() ? "disabled" : "enabled")
                   + " " + eachSubscription);
               }
             }
           }
           finally
           {
             for (Subscription eachSubscription : subscriptions)
             {
               eachSubscription.dispose();
             }
           }
 
           d("Requesting elemhide selectors from AdblockEngine for " + url + " in " + this);
-          List<String> selectors = adblockEngineProvider
-            .getAdblockEngine()
+          List<String> selectors = provider
+            .getEngine()
             .getElementHidingSelectors(url, domain, referrers);
 
           d("Finished requesting elemhide selectors, got " + selectors.size() + " in " + this);
           selectorsString = Utils.stringListToJsonArray(selectors);
         }
       }
       finally
       {
         if (!isCancelled.get())
         {
@@ skipping 55 matching lines @@
         w("elemHideThread set to null");
         elemHideThread = null;
       }
     }
   };
 
   private void initAbpLoading()
   {
     getSettings().setJavaScriptEnabled(true);
     buildInjectJs();
-    initEngineProvider();
+    initProvider();
   }
 
-  private void initEngineProvider()
+  private void initProvider()
   {
-    // if AdblockWebView works as drop-in replacement for WebView 'adblockEngineProvider' is not set.
-    // Thus AdblockWebView is using SingletonEngineProvider instance
-    if (adblockEngineProvider == null)
+    // if AdblockWebView works as drop-in replacement for WebView 'provider' is not set.
+    // Thus AdblockWebView is using SingleInstanceEngineProvider instance
+    if (provider == null)
     {
-      setAdblockEngineProvider(new SingletonEngineProvider(
+      setProvider(new SingleInstanceEngineProvider(
         getContext(), AdblockEngine.BASE_PATH_DIRECTORY, debugMode));
     }
   }
 
   private void startAbpLoading(String newUrl)
   {
     d("Start loading " + newUrl);
 
     loading = true;
     addDomListener = true;
     elementsHidden = false;
     loadError = null;
     url = newUrl;
 
     if (url != null)
     {
       try
       {
-        adblockEngineProvider.waitForReady();
-        domain = adblockEngineProvider.getAdblockEngine().getFilterEngine().getHostFromURL(url);
+        d("Waiting for adblock engine");
+        provider.waitForReady();
+
+        domain = provider.getEngine().getFilterEngine().getHostFromURL(url);
         if (domain == null)
         {
           throw new RuntimeException("Failed to extract domain from " + url);
         }
 
         d("Extracted domain " + domain + " from " + url);
       }
       catch (Throwable t)
       {
         e("Failed to extract domain from " + url, t);
@@ skipping 241 matching lines @@
       catch (InterruptedException e)
       {
         w("Interrupted, returning empty selectors list");
         return EMPTY_ELEMHIDE_ARRAY_STRING;
       }
     }
   }
 
   private void doDispose()
   {
-    adblockEngineProvider.release();
+    w("Disposing AdblockEngine");
+    provider.release();
   }
 
   private class DisposeRunnable implements Runnable
   {
     private Runnable disposeFinished;
 
     private DisposeRunnable(Runnable disposeFinished)
     {
       this.disposeFinished = disposeFinished;
     }
@@ skipping 13 matching lines @@
   /**
    * Dispose AdblockWebView and internal adblockEngine if it was created
    * If external AdblockEngine was passed using `setAdblockEngine()` it should be disposed explicitly
    * Warning: runnable can be invoked from background thread
    * @param disposeFinished runnable to run when AdblockWebView is disposed
    */
   public void dispose(final Runnable disposeFinished)
   {
     d("Dispose invoked");
 
-    if (adblockEngineProvider == null)
+    if (provider == null)
     {
       d("No internal AdblockEngineProvider created");
       return;
     }
 
     stopLoading();
 
     DisposeRunnable disposeRunnable = new DisposeRunnable(disposeFinished);
     synchronized (elemHideThreadLockObject)
     {
       if (elemHideThread != null)
       {
         w("Busy with elemhide selectors, delayed disposing scheduled");
         elemHideThread.setFinishedRunnable(disposeRunnable);
       }
       else
       {
         disposeRunnable.run();
       }
     }
   }
 }