Issue #2230, #3391 - Load filters on "download begin" event

test/plugin/DetachedInitializationTest.cpp

 /*
  * This file is part of Adblock Plus <https://adblockplus.org/>,
  * Copyright (C) 2006-2015 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 16 matching lines @@
 const std::string failMessage = "initializer failed on purpose";
 void FailFunction()
 {
   throw std::runtime_error(failMessage);
 }
 
 /*
  * The destructor has to be able to block to wait for the initializer
  * This test ensures that it doesn't block unnecessarily.
  */
-TEST(DetachedInitializer, DestructorDoesNotBlockAfterNoActivity)
+TEST(DetachedInitializerStaticFunction, DestructorDoesNotBlockAfterNoActivity)
 {
-  DetachedInitializer<NullFunction> x;
+  DetachedInitializerStaticFunction<NullFunction> x;
 }
 
-TEST(DetachedInitializer, NullInstance)
+TEST(DetachedInitializerStaticFunction, NullInstance)
 {
   ASSERT_NO_THROW(
     {
-      DetachedInitializer<NullFunction> x;
+      DetachedInitializerStaticFunction<NullFunction> x;
       x.SpawnInitializer();
       x.EnsureInitialized();
     }
   );
 }
 
 /*
  * This test illustrates a defect in Google Test.
  * This test fails with a message that the test threw an exception.
  * The exception message is the one thrown by FailFunction.
  * It does not fail, importantly, because SpawnInitializer() throws.
  * This can be verified in the debugger.
  *
  * It's disabled in the present code base so it doesn't break the unit test.
  * Check this test again when we upgrade past GTest 1.60 and the VS 2012 toolset.
  */
-TEST(DetachedInitializer, DISABLED_EnsureInitializedThrowingGtestDefectIllustration)
+TEST(DetachedInitializerStaticFunction, DISABLED_EnsureInitializedThrowingGtestDefectIllustration)
 {
-  DetachedInitializer<FailFunction> x;
+  DetachedInitializerStaticFunction<FailFunction> x;
   bool threw = false;
   try
   {
     x.SpawnInitializer();
   }
   catch (...)
   {
     threw = true;
     FAIL() << "SpawnInitializer() threw";
   }
   ASSERT_FALSE(threw);
 }
 
 /*
  * This test fails because of a defect in Google Test.
  * It's disabled at present, but should be enabled when the previous test is working.
  */
-TEST(DetachedInitializer, DISABLED_EnsureInitializedThrowing)
+TEST(DetachedInitializerStaticFunction, DISABLED_EnsureInitializedThrowing)
 {
-  DetachedInitializer<FailFunction> x;
+  DetachedInitializerStaticFunction<FailFunction> x;
   try
   {
     x.SpawnInitializer();
   }
   catch (...)
   {
     FAIL() << "SpawnInitializer() threw";
     return;
   }
   try
   {
     x.EnsureInitialized();
     FAIL() << "EnsureInitialized() did not throw";
   }
   catch (std::runtime_error& e)
   {
     ASSERT_EQ(failMessage, e.what());
   }
 }
 
 /*
- * Resetable version of DetachedInitializer
+ * Resetable version of DetachedInitializerStaticFunction
  */
 template<void(&F)()>
-class DidReset
-  : public DetachedInitializer<F>
+class DisfReset
+  : public DetachedInitializerStaticFunction<F>
 {
 public:
   void Reset()
   {
     isInitializationComplete.store(false, std::memory_order_relaxed);
     hasInitializerStarted.store(false, std::memory_order_relaxed);
     initializerException = nullptr;
     // Lock and unlock the mutex to clear any previous state
     // It will also detect a locked mutex left over from a previous test.
     mutex.lock();
     mutex.unlock();
   }
 };
 
 /*
- * Uses designated implementation pattern of DetachedInitializer
+ * Uses designated implementation pattern of DetachedInitializerStaticFunction
  */
 struct DeferredIncrementingInitializer
 {
   static int initializedCount;
 
   static void Incrementer()
   {
     ++initializedCount;
   }
 
-  typedef DidReset<Incrementer> InitializerType;
+  typedef DisfReset<Incrementer> InitializerType;
   static InitializerType di;
 
 public:
   DeferredIncrementingInitializer()
   {
     di.SpawnInitializer();
   }
 
   static void ResetClass()
   {
@@ skipping 40 matching lines @@
 TEST(DetachedInitializer, Many)
 {
   DeferredIncrementingInitializer::ResetClass();
   const int many = 1000000;
   for (int j = 0; j < many;++j)
   {
     DeferredIncrementingInitializer x;
   }
   ASSERT_EQ(1, DeferredIncrementingInitializer::GetInitializerCount());
 }