Issue 6454 - IllegalStateException crash

adblockplussbrowser/src/main/java/org/adblockplus/sbrowser/contentblocker/engine/EngineManager.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
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with Adblock Plus.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 package org.adblockplus.sbrowser.contentblocker.engine;
 
 import android.content.Context;
 import android.os.AsyncTask;
 
 import java.io.IOException;
 import java.lang.ref.WeakReference;
 import java.util.ArrayList;
 import java.util.Iterator;
 import java.util.List;
 

[jens, 2018/03/08 09:18:40]

I didn't want to leave a lot of single comments, but is there a reason that the
method parameters in this class are all not final?

[diegocarloslima, 2018/03/08 11:54:34]

Nope, the reason is just that I don't usually mark the method parameters as
final (only when they're needed in a inner class). But I think we can agree to
when possible, mark everything as final. I think that won't hurt and can
sometimes improve performance.

[jens, 2018/03/08 12:33:54]

Acknowledged.

 public class EngineManager
 {
   private static final EngineManager INSTANCE = new EngineManager();
 
   private Engine engine;
   private CreateEngineAsyncTask createEngineTask;
   private final List<WeakReference<OnEngineCreatedCallback>> engineCreatedCallbacks = new ArrayList<>();
 
   private EngineManager()
   {
   }
 
   public static EngineManager getInstance()
   {
     return INSTANCE;
   }
 
-  public void retrieveEngine(Context context, OnEngineCreatedCallback callback)
+  public void retrieveEngine(final Context context, final OnEngineCreatedCallback callback)
   {
     synchronized (engineCreatedCallbacks)
     {
       if (callback != null)
       {
         engineCreatedCallbacks.add(new WeakReference<>(callback));
       }
     }
     if (engine != null)
     {
       notifyEngineCreated();
     }
     else if (createEngineTask == null || createEngineTask.isCancelled())
     {
       this.createEngineTask = new CreateEngineAsyncTask();
       this.createEngineTask.execute(context);
     }
   }
 
-  public void removeEngineCreatedCallback(OnEngineCreatedCallback callback)
+  public void removeOnEngineCreatedCallback(final OnEngineCreatedCallback callback)
   {
     if (callback != null)
     {
       synchronized (engineCreatedCallbacks)
       {
         final Iterator<WeakReference<OnEngineCreatedCallback>> iterator = engineCreatedCallbacks.iterator();
         while (iterator.hasNext())
         {
           final OnEngineCreatedCallback cb = iterator.next().get();
           if (callback.equals(cb))
           {
             iterator.remove();
           }
         }
       }
     }
   }
 
-  private void setEngineAndNotify(Engine engine)
+  private void setEngineAndNotify(final Engine engine)
   {
     this.createEngineTask = null;
     this.engine = engine;
     notifyEngineCreated();
   }
 
   private void notifyEngineCreated()
   {
     synchronized (engineCreatedCallbacks)
     {
@@ skipping 18 matching lines @@
   }
 
   public interface OnEngineCreatedCallback
   {
     void onEngineCreated(Engine engine);
   }
 
   private static final class CreateEngineAsyncTask extends AsyncTask<Context, Void, Engine>
   {
     @Override
-    protected Engine doInBackground(Context... context)
+    protected Engine doInBackground(final Context... context)
     {
       try
       {
         return Engine.create(context[0].getApplicationContext());
       }
       catch (IOException e)
       {
       }
       return null;
     }
 
     @Override
-    protected void onPostExecute(Engine engine)
+    protected void onPostExecute(final Engine engine)
     {
       EngineManager.getInstance().setEngineAndNotify(engine);
     }
   }
 }