Issue 119 - Switch to injecting CSS for element hiding

src/plugin/PluginTabBase.cpp

 /*
  * This file is part of Adblock Plus <https://adblockplus.org/>,
- * Copyright (C) 2006-2015 Eyeo GmbH
+ * Copyright (C) 2006-2016 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/>.
  */
 
 #include "PluginStdAfx.h"
 #include "AdblockPlusClient.h"
 #include "PluginClientBase.h"
 #include "PluginSettings.h"
 #include "AdblockPlusDomTraverser.h"
 #include "PluginTabBase.h"
 #include "IeVersion.h"
 #include "../shared/Utils.h"
+#include "../shared/EventWithSetter.h"
 #include <Mshtmhst.h>
-#include "../shared/Utils.h"
-
-CPluginTabBase::CPluginTabBase(CPluginClass* plugin)
-  : m_plugin(plugin)
-  , m_isActivated(false)
+#include <mutex>
+
+class CPluginTab::AsyncPluginFilter
+{
+public:
+  static std::shared_ptr<AsyncPluginFilter> CreateAsync(const std::wstring& domain)
+  {
+    std::shared_ptr<AsyncPluginFilter> asyncFilter = std::make_shared<AsyncPluginFilter>();
+    std::weak_ptr<AsyncPluginFilter> weakAsyncData = asyncFilter;
+    auto eventSetter = asyncFilter->event.CreateSetter();
+    try
+    {
+      std::thread([domain, weakAsyncData, eventSetter]
+      {
+        try
+        {
+          CreateAsyncImpl(domain, weakAsyncData, eventSetter);
+        }
+        catch (...)
+        {
+          // As a thread-main function, we truncate any C++ exception.
+        }
+      }).detach();
+      // TODO: we should do something with that `detach` above.
+    }
+    catch (const std::system_error& ex)
+    {
+      DEBUG_SYSTEM_EXCEPTION(ex, PLUGIN_ERROR_THREAD, PLUGIN_ERROR_MAIN_THREAD_CREATE_PROCESS,
+        "Class::Thread - Failed to start filter loader thread");
+    }
+    return asyncFilter;
+  }
+  PluginFilterPtr GetFilter()
+  {
+    if (!event.Wait())
+      return PluginFilterPtr();
+    std::lock_guard<std::mutex> lock(mutex);
+    return filter;
+  }
+private:
+  static void CreateAsyncImpl(const std::wstring& domain, std::weak_ptr<AsyncPluginFilter> weakAsyncData, const std::shared_ptr<EventWithSetter::Setter>& setter)
+  {
+    std::unique_ptr<CPluginFilter> pluginFilter(new CPluginFilter(CPluginClient::GetInstance()->GetElementHidingSelectors(domain)));
+    if (auto asyncData = weakAsyncData.lock())
+    {
+      {
+        std::lock_guard<std::mutex> lock(asyncData->mutex);
+        asyncData->filter = move(pluginFilter);
+      }
+      setter->Set();
+    }
+  }
+  EventWithSetter event;
+  std::mutex mutex;
+  PluginFilterPtr filter;
+};
+
+CPluginTab::CPluginTab()
+  : m_isActivated(false)
   , m_continueThreadRunning(true)
 {
-  m_filter = std::auto_ptr<CPluginFilter>(new CPluginFilter());
-  m_filter->hideFiltersLoadedEvent = CreateEvent(NULL, true, false, NULL);
-
   CPluginClient* client = CPluginClient::GetInstance();
   if (AdblockPlus::IE::InstalledMajorVersion() < 10)
   {
     m_isActivated = true;
   }
 
   try
   {
-    m_thread = std::thread(&CPluginTabBase::ThreadProc, this);
+    m_thread = std::thread(&CPluginTab::ThreadProc, this);
   }
   catch (const std::system_error& ex)
   {
     DEBUG_SYSTEM_EXCEPTION(ex, PLUGIN_ERROR_THREAD, PLUGIN_ERROR_TAB_THREAD_CREATE_PROCESS,
       "Tab::Thread - Failed to create tab thread");
   }
-  m_traverser = new CPluginDomTraverser(static_cast<CPluginTab*>(this));
-}
-
-
-CPluginTabBase::~CPluginTabBase()
-{
-  delete m_traverser;
-  m_traverser = NULL;
+}
+
+
+CPluginTab::~CPluginTab()
+{
   m_continueThreadRunning = false;
   if (m_thread.joinable()) {
     m_thread.join();
   }
 }
 
-void CPluginTabBase::OnActivate()
+/**
+ * ABP only intercepts protocols "http:" and "https:".
+ * We can disable any domain used in those protocol with an appropriate whitelist filter.
+ * Thus, the possibility to disable on a particular site depends only on the protocol.
+ */
+bool CPluginTab::IsPossibleToDisableOnSite()
+{
+  auto url = GetDocumentUrl();
+  return BeginsWith(url, L"http:") || BeginsWith(url, L"https:");
+}
+
+void CPluginTab::OnActivate()
 {
   m_isActivated = true;
 }
 
 
-void CPluginTabBase::OnUpdate()
+void CPluginTab::OnUpdate()
 {
   m_isActivated = true;
 }
 
-namespace
-{
-  // Entry Point
-  void FilterLoader(CPluginTabBase* tabBase)
-  {
-    try
-    {
-      tabBase->m_filter->LoadHideFilters(CPluginClient::GetInstance()->GetElementHidingSelectors(tabBase->GetDocumentDomain()));
-      SetEvent(tabBase->m_filter->hideFiltersLoadedEvent);
-    }
-    catch (...)
-    {
-      // As a thread-main function, we truncate any C++ exception.
-    }
-  }
-}
-
-void CPluginTabBase::OnNavigate(const std::wstring& url)
+void CPluginTab::OnNavigate(const std::wstring& url)
 {
   SetDocumentUrl(url);
-  ClearFrameCache(GetDocumentDomain());
-  std::wstring domainString = GetDocumentDomain();
-  ResetEvent(m_filter->hideFiltersLoadedEvent);
-  try
-  {
-    std::thread filterLoaderThread(&FilterLoader, this);
-    filterLoaderThread.detach(); // TODO: but actually we should wait for the thread in the dtr.
-  }
-  catch (const std::system_error& ex)
-  {
-    DEBUG_SYSTEM_EXCEPTION(ex, PLUGIN_ERROR_THREAD, PLUGIN_ERROR_MAIN_THREAD_CREATE_PROCESS,
-      "Class::Thread - Failed to start filter loader thread");
-  }
-  m_traverser->ClearCache();
+  std::wstring domain = GetDocumentDomain();
+  ClearFrameCache(domain);
+  m_asyncPluginFilter = AsyncPluginFilter::CreateAsync(domain);
+  m_traverser.reset();
 }
 
 namespace
 {
   /**
    * Determine if the HTML file is one of ours.
    * The criterion is that it appear in the "html/templates" folder within our installation.
    *
    * Warning: This function may fail if the argument is not a "file://" URL.
    * This is occasionally the case in circumstances yet to be characterized.
@@ skipping 20 matching lines @@
       return false;
     }
     auto urlCstr = url.c_str();
     // Check the prefix to match our directory
     // Check the suffix to be an HTML file
     return (_wcsnicmp(urlCstr, dir.c_str(), dir.length()) == 0) &&
       (_wcsnicmp(urlCstr + url.length() - 5, L".html", 5) == 0);
   }
 }
 
-void CPluginTabBase::InjectABP(IWebBrowser2* browser)
+void CPluginTab::InjectABP(IWebBrowser2* browser)
 {
   CriticalSection::Lock lock(m_csInject);
   auto url = GetDocumentUrl();
   if (!IsOurHtmlFile(url))
   {
     DEBUG_GENERAL(L"InjectABP. Not injecting");
     return;
   }
   DEBUG_GENERAL(L"InjectABP. Injecting");
   CComPtr<IDispatch> pDocDispatch;
   browser->get_Document(&pDocDispatch);
   CComQIPtr<IHTMLDocument2> pDoc2(pDocDispatch);
   if (!pDoc2)
   {
-    DEBUG_ERROR_LOG(0, PLUGIN_ERROR_CREATE_SETTINGS_JAVASCRIPT, PLUGIN_ERROR_CREATE_SETTINGS_JAVASCRIPT_INVOKE, "CPluginTabBase::InjectABP - Failed to QI document");
-    return;
-  }
-
+    DEBUG_ERROR_LOG(0, PLUGIN_ERROR_CREATE_SETTINGS_JAVASCRIPT, PLUGIN_ERROR_CREATE_SETTINGS_JAVASCRIPT_INVOKE, "CPluginTab::InjectABP - Failed to QI document");
+    return;
+  }
   CComPtr<IHTMLWindow2> pWnd2;
   pDoc2->get_parentWindow(&pWnd2);
   if (!pWnd2)
   {
-    DEBUG_ERROR_LOG(0, PLUGIN_ERROR_CREATE_SETTINGS_JAVASCRIPT, PLUGIN_ERROR_CREATE_SETTINGS_JAVASCRIPT_INVOKE, "CPluginTabBase::InjectABP - Failed to get parent window");
+    DEBUG_ERROR_LOG(0, PLUGIN_ERROR_CREATE_SETTINGS_JAVASCRIPT, PLUGIN_ERROR_CREATE_SETTINGS_JAVASCRIPT_INVOKE, "CPluginTab::InjectABP - Failed to get parent window");
     return;
   }
   CComQIPtr<IDispatchEx> pWndEx(pWnd2);
   if (!pWndEx)
   {
-    DEBUG_ERROR_LOG(0, PLUGIN_ERROR_CREATE_SETTINGS_JAVASCRIPT, PLUGIN_ERROR_CREATE_SETTINGS_JAVASCRIPT_INVOKE, "CPluginTabBase::InjectABP - Failed to QI dispatch");
+    DEBUG_ERROR_LOG(0, PLUGIN_ERROR_CREATE_SETTINGS_JAVASCRIPT, PLUGIN_ERROR_CREATE_SETTINGS_JAVASCRIPT_INVOKE, "CPluginTab::InjectABP - Failed to QI dispatch");
     return;
   }
   // Create "Settings" object in JavaScript.
   // A method call of "Settings" in JavaScript, transfered to "Invoke" of m_pluginUserSettings
   DISPID dispid;
   HRESULT hr = pWndEx->GetDispID(L"Settings", fdexNameEnsure, &dispid);
   if (FAILED(hr))
   {
-    DEBUG_ERROR_LOG(hr, PLUGIN_ERROR_CREATE_SETTINGS_JAVASCRIPT, PLUGIN_ERROR_CREATE_SETTINGS_JAVASCRIPT_INVOKE, "CPluginTabBase::InjectABP - Failed to get dispatch");
+    DEBUG_ERROR_LOG(hr, PLUGIN_ERROR_CREATE_SETTINGS_JAVASCRIPT, PLUGIN_ERROR_CREATE_SETTINGS_JAVASCRIPT_INVOKE, "CPluginTab::InjectABP - Failed to get dispatch");
     return;
   }
   CComVariant var((IDispatch*)&m_pluginUserSettings);
 
   DEBUG_GENERAL("Injecting");
 
   DISPPARAMS params;
   params.cArgs = 1;
   params.cNamedArgs = 0;
   params.rgvarg = &var;
   params.rgdispidNamedArgs = 0;
   hr = pWndEx->Invoke(dispid, IID_NULL, LOCALE_USER_DEFAULT, DISPATCH_PROPERTYPUT | DISPATCH_PROPERTYPUTREF, &params, 0, 0, 0);
   DEBUG_GENERAL("Invoke");
   if (FAILED(hr))
   {
-    DEBUG_ERROR_LOG(hr, PLUGIN_ERROR_CREATE_SETTINGS_JAVASCRIPT, PLUGIN_ERROR_CREATE_SETTINGS_JAVASCRIPT_INVOKE, "CPluginTabBase::InjectABP - Failed to create Settings in JavaScript");
-  }
-}
-
-bool CPluginTabBase::IsTraverserEnabled()
+    DEBUG_ERROR_LOG(hr, PLUGIN_ERROR_CREATE_SETTINGS_JAVASCRIPT, PLUGIN_ERROR_CREATE_SETTINGS_JAVASCRIPT_INVOKE, "CPluginTab::InjectABP - Failed to create Settings in JavaScript");
+  }
+}
+
+bool CPluginTab::IsTraverserEnabled()
 {
   return !IsCSSInjectionEnabled();
 }
 
-bool CPluginTabBase::IsCSSInjectionEnabled()
+bool CPluginTab::IsCSSInjectionEnabled()
 {
   return IsWindowsVistaOrLater() && AdblockPlus::IE::InstalledMajorVersion() >= 10;
 }

[Eric, 2015/12/02 17:00:15]

I'd like to see a user setting for these predicates that can override what's
already here. The use cases are for developers running and debugging traverser
code. Without something we can override, it's going to be quite a bother
degrading the IE version just to run the traverser code.

I suggest two mechanisms.

(1) An in-memory static variable that can be explicitly toggled inside the VS
debugger. This can be evaluated the first time and left alone after that, which
means a second "is initialized" value somewhere.

(2) An external configuration option, either in a file or in the registry, that
configures operation when not running under the debugger.

[sergei, 2016/02/25 17:48:28]

I have created those methods exactly for that reason.
Currently developers can insert `return false;` here or add some code to read it
from some file (3 lines of code) or use something else. Not so difficult, I
guess.

I agree that we need some external flag, see #3631.

 
 namespace
 {
   void InjectABPCSS(IHTMLDocument2& htmlDocument2, const std::vector<std::wstring>& hideFilters)
   {
     // pseudocode: styleHtmlElement = htmlDocument2.createElement("style");
     ATL::CComQIPtr<IHTMLStyleElement> styleHtmlElement;
     {
       ATL::CComPtr<IHTMLElement> stylePureHtmlElement;
       if (FAILED(htmlDocument2.createElement(ATL::CComBSTR(L"style"), &stylePureHtmlElement)))
@@ skipping 130 matching lines @@
     while(frame = GetParent(*frame))
     {
       frameHierarchy.push_back(ToUtf8String(GetLocationUrl(*frame)));
     }
     CPluginClient* client = CPluginClient::GetInstance();
     return client->IsWhitelistedUrl(url, frameHierarchy)
         || client->IsElemhideWhitelistedOnDomain(url, frameHierarchy);
   }
 }
 
-void CPluginTabBase::OnDownloadComplete(IWebBrowser2* browser)
+void CPluginTab::OnDownloadComplete(IWebBrowser2* browser)
 {
   if (IsTraverserEnabled())
   {
     CPluginClient* client = CPluginClient::GetInstance();
     std::wstring url = GetDocumentUrl();
     if (!client->IsWhitelistedUrl(url) && !client->IsElemhideWhitelistedOnDomain(url))
     {
-      m_traverser->TraverseDocument(browser, GetDocumentDomain(), GetDocumentUrl());
+      if (!m_traverser)
+      {
+        assert(m_asyncPluginFilter && "Filter initialization should be already at least started");
+        if (m_asyncPluginFilter)
+        {
+          auto pluginFilter = m_asyncPluginFilter->GetFilter();
+          assert(pluginFilter && "Plugin filter should be a valid object");
+          if (pluginFilter)
+            m_traverser.reset(new CPluginDomTraverser(pluginFilter));
+        }
+      }
+      assert(m_traverser && "Traverser should be a valid object");
+      if (m_traverser)
+        m_traverser->TraverseDocument(browser, GetDocumentDomain(), GetDocumentUrl());
     }
   }
   InjectABP(browser);
 }
 
-void CPluginTabBase::OnDocumentComplete(IWebBrowser2* browser, const std::wstring& url, bool isDocumentBrowser)
+void CPluginTab::OnDocumentComplete(IWebBrowser2* browser, const std::wstring& url, bool isDocumentBrowser)
 {
   std::wstring documentUrl = GetDocumentUrl();
 
   if (isDocumentBrowser)
   {
     if (url != documentUrl)
     {
       SetDocumentUrl(url);
     }
     InjectABP(browser);
   }
-  CString urlLegacy = ToCString(url);
-  if (urlLegacy.Left(6) == "res://")
+  if (BeginsWith(url, L"res://"))
   {
     return;
   }

[Eric, 2015/12/02 17:00:15]

This optimization, for early return on a "res://" URL, could be committed
separately and immediately. It will make the changes below easier to review. At
present it all looks different because the indentation changes, when in fact
most of it's the same.

[sergei, 2016/02/25 17:48:28]

Done. It's already not relevant.

   // Get document
   CComPtr<IDispatch> pDocDispatch;
   HRESULT hr = browser->get_Document(&pDocDispatch);
   if (FAILED(hr) || !pDocDispatch)
   {
     return;
   }
 
   CComQIPtr<IHTMLDocument2> pDoc(pDocDispatch);
   if (!pDoc)
   {
     return;
   }
 
   if (IsCSSInjectionEnabled() && CPluginSettings::GetInstance()->GetPluginEnabled())
   {
     if (!IsFrameWhiteListed(browser))
     {
       DEBUG_GENERAL(L"Inject CSS into " + url);
-      InjectABPCSS(*pDoc, m_filter->GetHideFilters());
-    }
-  }
-
-  ATL::CComQIPtr<IOleObject> pOleObj(pDocDispatch);
+      assert(m_asyncPluginFilter && "Filter initialization should be already at least started");
+      if (m_asyncPluginFilter)
+      {
+        auto pluginFilter = m_asyncPluginFilter->GetFilter();
+        assert(pluginFilter && "Plugin filter should be a valid object");
+        if (pluginFilter)
+        {
+          InjectABPCSS(*pDoc, pluginFilter->GetHideFilters());
+        }
+      }
+    }
+  }
+
+  CComPtr<IOleObject> pOleObj;
+  pDocDispatch->QueryInterface(&pOleObj);
   if (!pOleObj)
-    return;
-
-  ATL::CComQIPtr<IOleClientSite> pClientSite;
+  {
+    return;
+  }
+  CComPtr<IOleClientSite> pClientSite;
   pOleObj->GetClientSite(&pClientSite);
   if (pClientSite != NULL)
   {
-    ATL::CComQIPtr<IDocHostUIHandler> docHostUIHandler(pClientSite);
+    CComPtr<IDocHostUIHandler> docHostUIHandler;
+    pClientSite->QueryInterface(&docHostUIHandler);
     if (docHostUIHandler != NULL)
     {
       docHostUIHandler->UpdateUI();
     }
   }
 }
 
-std::wstring CPluginTabBase::GetDocumentDomain()
+std::wstring CPluginTab::GetDocumentDomain()
 {
   std::wstring domain;
 
   m_criticalSection.Lock();
   {
     domain = m_documentDomain;
   }
   m_criticalSection.Unlock();
 
   return domain;
 }
 
-void CPluginTabBase::SetDocumentUrl(const std::wstring& url)
+void CPluginTab::SetDocumentUrl(const std::wstring& url)
 {
   m_criticalSection.Lock();
   {
     m_documentUrl = url;
     m_documentDomain = CAdblockPlusClient::GetInstance()->GetHostFromUrl(url);
   }
   m_criticalSection.Unlock();
 }
 
-std::wstring CPluginTabBase::GetDocumentUrl()
+std::wstring CPluginTab::GetDocumentUrl()
 {
   std::wstring url;
 
   m_criticalSection.Lock();
   {
     url = m_documentUrl;
   }
   m_criticalSection.Unlock();
 
   return url;
 }
 
 
 // ============================================================================
 // Frame caching
 // ============================================================================
-bool CPluginTabBase::IsFrameCached(const std::wstring& url)
+bool CPluginTab::IsFrameCached(const std::wstring& url)
 {
   bool isFrame;
 
   m_criticalSectionCache.Lock();
   {
     isFrame = m_cacheFrames.find(url) != m_cacheFrames.end();
   }
   m_criticalSectionCache.Unlock();
 
   return isFrame;
 }
 
-void CPluginTabBase::CacheFrame(const std::wstring& url)
+void CPluginTab::CacheFrame(const std::wstring& url)
 {
   m_criticalSectionCache.Lock();
   {
     m_cacheFrames.insert(url);
   }
   m_criticalSectionCache.Unlock();
 }
 
-void CPluginTabBase::ClearFrameCache(const std::wstring& domain)
+void CPluginTab::ClearFrameCache(const std::wstring& domain)
 {
   m_criticalSectionCache.Lock();
   {
     if (domain.empty() || domain != m_cacheDomain)
     {
       m_cacheFrames.clear();
       m_cacheDomain = domain;
     }
   }
   m_criticalSectionCache.Unlock();
 }
 
-void CPluginTabBase::ThreadProc()
+void CPluginTab::ThreadProc()
 {
   // Force loading/creation of settings
-  CPluginSettings::GetInstance()->SetWorkingThreadId();
+  CPluginSettings::GetInstance();
 
   std::string message =
     "================================================================================\n"
     "TAB THREAD process=";
   message += std::to_string(::GetCurrentProcessId());
   message + " thread=";
   message += std::to_string(::GetCurrentThreadId());
   message +=
     "\n"
     "================================================================================";
@@ skipping 32 matching lines @@
           LogQueue::LogPluginError(pluginError.GetErrorCode(), pluginError.GetErrorId(), pluginError.GetErrorSubid(), pluginError.GetErrorDescription(), true, pluginError.GetProcessId(), pluginError.GetThreadId());
         }
 
         // Non-hanging sleep
         Sleep(50);
       }
 
       tabLoopIteration++;
   }
 }