Issue #1467, #3397 - Rewrite the map from threads to tabs

src/plugin/PluginWbPassThrough.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.
  *
@@ skipping 19 matching lines @@
           "<!-- blocked by AdblockPlus -->"
         "</body>"
     "</html>";
 
   template <typename T>
   T ASCIIStringToLower(const T& text)
   {
     T textlower;
     std::transform(text.begin(), text.end(), std::back_inserter(textlower), 
       [](T::value_type ch)
-          { 
-            return std::tolower(ch, std::locale());
-          }
-        );
+      {
+        return std::tolower(ch, std::locale());
+      }
+    );
     return textlower;
   }
 
   typedef AdblockPlus::FilterEngine::ContentType ContentType;
 
   template <class T>
   T ExtractHttpHeader(const T& allHeaders, const T& targetHeaderNameWithColon, const T& delimiter)
   {
     const T allHeadersLower = ASCIIStringToLower(allHeaders);
     auto targetHeaderBeginsAt = allHeadersLower.find(ASCIIStringToLower(targetHeaderNameWithColon));
@@ skipping 78 matching lines @@
   }
 }
 
 WBPassthruSink::WBPassthruSink()
   : m_currentPositionOfSentPage(0)
   , m_contentType(ContentType::CONTENT_TYPE_OTHER)
   , m_isCustomResponse(false)
 {
 }
 
-ContentType WBPassthruSink::GetContentTypeFromMimeType(const CString& mimeType)
-{
-  if (mimeType.Find(L"image/") >= 0)
-  {
-    return ContentType::CONTENT_TYPE_IMAGE;
-  }
-  if (mimeType.Find(L"text/css") >= 0)
-  {
-    return ContentType::CONTENT_TYPE_STYLESHEET;
-  }
-  if ((mimeType.Find(L"application/javascript") >= 0) || (mimeType.Find(L"application/json") >= 0))
-  {
-    return ContentType::CONTENT_TYPE_SCRIPT;
-  }
-  if (mimeType.Find(L"application/x-shockwave-flash") >= 0)
-  {
-    return ContentType::CONTENT_TYPE_OBJECT;
-  }
-  if (mimeType.Find(L"text/html") >= 0)
-  {
-    return ContentType::CONTENT_TYPE_SUBDOCUMENT;
-  }
-  // It is important to have this check last, since it is rather generic, and might overlay text/html, for example
-  if (mimeType.Find(L"xml") >= 0)
-  {
-    return ContentType::CONTENT_TYPE_XMLHTTPREQUEST;
-  }
-
-  return ContentType::CONTENT_TYPE_OTHER;
-}
-
-ContentType WBPassthruSink::GetContentTypeFromURL(const std::wstring& src)
-{
-  std::wstring schemeAndHierarchicalPart = GetSchemeAndHierarchicalPart(src);
-  auto contentType = GetContentTypeFromString(schemeAndHierarchicalPart);
-  if (contentType == ContentType::CONTENT_TYPE_OTHER &&
-    AdblockPlus::IE::InstalledMajorVersion() == 8)
-  {
-    std::wstring queryString = GetQueryString(src);
-    wchar_t* nextToken = nullptr;
-    const wchar_t* token = wcstok_s(&queryString[0], L"&=", &nextToken);
-    while (token != nullptr)
-    {
-      contentType = GetContentTypeFromString(token);
-      if (contentType != ContentType::CONTENT_TYPE_OTHER)
+namespace
+{
+  /**
+   * Heuristic to infer an ABP content type from the media type list of an Accept: header field.
+   *
+   * Known IE Accept: strings for documents and images:
+   *     text/html, application/xhtml+xml, image/jxr, *\/*
+   *     image/png, image/svg+xml, image/jxr, image/*;q=0.8, *\/*;q = 0.5
+   * In IE9 the image/jxr part is missing.
+   */
+  ContentType InferContentTypeFromMediaTypeList(const std::wstring& mediaTypeList)
+  {
+    if ((mediaTypeList.find(L"text/html") != std::wstring::npos) ||
+      (mediaTypeList.find(L"application/xhtml+xml") != std::wstring::npos))
+    {
+      return ContentType::CONTENT_TYPE_SUBDOCUMENT;
+    }
+    if (mediaTypeList.find(L"image/") != std::wstring::npos)
+    {
+      return ContentType::CONTENT_TYPE_IMAGE;
+    }
+    if (mediaTypeList.find(L"text/css") != std::wstring::npos)
+    {
+      return ContentType::CONTENT_TYPE_STYLESHEET;
+    }
+    if ((mediaTypeList.find(L"application/javascript") != std::wstring::npos) || (mediaTypeList.find(L"application/json") != std::wstring::npos))
+    {
+      return ContentType::CONTENT_TYPE_SCRIPT;
+    }
+    if (mediaTypeList.find(L"application/x-shockwave-flash") != std::wstring::npos)
+    {
+      return ContentType::CONTENT_TYPE_OBJECT;
+    }
+    // It is important to have this check last, since it is rather generic, and might overlay text/html, for example
+    if (mediaTypeList.find(L"xml") != std::wstring::npos)
+    {
+      return ContentType::CONTENT_TYPE_XMLHTTPREQUEST;
+    }
+    return ContentType::CONTENT_TYPE_OTHER;
+  }
+
+  ContentType InferContentTypeFromUrl(const std::wstring& src)
+  {
+    std::wstring schemeAndHierarchicalPart = GetSchemeAndHierarchicalPart(src);
+    auto contentType = GetContentTypeFromString(schemeAndHierarchicalPart);
+    if (contentType == ContentType::CONTENT_TYPE_OTHER &&
+      AdblockPlus::IE::InstalledMajorVersion() == 8)
+    {
+      std::wstring queryString = GetQueryString(src);
+      wchar_t* nextToken = nullptr;
+      const wchar_t* token = wcstok_s(&queryString[0], L"&=", &nextToken);
+      while (token != nullptr)
       {
-         return contentType;
+        contentType = GetContentTypeFromString(token);
+        if (contentType != ContentType::CONTENT_TYPE_OTHER)
+        {
+           return contentType;
+        }
+        token = wcstok_s(nullptr, L"&=", &nextToken);
       }
-      token = wcstok_s(nullptr, L"&=", &nextToken);
-    }
-  }
-  return contentType;
-}
-
-ContentType WBPassthruSink::GetContentType(const CString& mimeType, const std::wstring& domain, const std::wstring& src)
-{
-  // No referer or mime type
-  // BINDSTRING_XDR_ORIGIN works only for IE v8+
-  if (mimeType.IsEmpty() && domain.empty() && AdblockPlus::IE::InstalledMajorVersion() >= 8)
-  {
-    return ContentType::CONTENT_TYPE_XMLHTTPREQUEST;
-  }
-  ContentType contentType = GetContentTypeFromMimeType(mimeType);
-  if (contentType == ContentType::CONTENT_TYPE_OTHER)
-  {
-    contentType = GetContentTypeFromURL(src);
-  }
-  return contentType;
+    }
+    return contentType;
+  }
+
+  ContentType InferContentType(const std::wstring& mediaTypeList, const std::wstring& domain, const std::wstring& src)
+  {
+    // No referer or mime type
+    // BINDSTRING_XDR_ORIGIN works only for IE v8+
+    if (mediaTypeList.empty() && domain.empty() && AdblockPlus::IE::InstalledMajorVersion() >= 8)
+    {
+      return ContentType::CONTENT_TYPE_XMLHTTPREQUEST;
+    }
+    ContentType contentType = InferContentTypeFromMediaTypeList(mediaTypeList);
+    if (contentType == ContentType::CONTENT_TYPE_OTHER)
+    {
+      contentType = InferContentTypeFromUrl(src);
+    }
+    return contentType;
+  }
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////
 //WBPassthruSink
 //Monitor and/or cancel every request and responde
 //WB makes, including images, sounds, scripts, etc
 ////////////////////////////////////////////////////////////////////////////////////////
 HRESULT WBPassthruSink::OnStart(LPCWSTR szUrl, IInternetProtocolSink *pOIProtSink,
                                 IInternetBindInfo *pOIBindInfo, DWORD grfPI, HANDLE_PTR dwReserved,
-                                IInternetProtocol* pTargetProtocol, bool& handled)
+                                IInternetProtocol* pTargetProtocol)
 {
   m_pTargetProtocol = pTargetProtocol;
   return BaseClass::OnStart(szUrl, pOIProtSink, pOIBindInfo, grfPI, dwReserved, pTargetProtocol);
 }
 
 HRESULT WBPassthruSink::OnRead(void* pv, ULONG cb, ULONG* pcbRead)
 {
   if (!pv || !pcbRead)
   {
     return E_POINTER;
   }
   *pcbRead = 0;
 
-  if (PassthroughAPP::CustomSinkStartPolicy<WBPassthru, WBPassthruSink>::GetProtocol(this)->m_shouldSupplyCustomContent)
+  if (PassthroughAPP::CustomSinkStartPolicy<WbPassthroughProtocol, WBPassthruSink>::GetProtocol(this)->m_shouldSupplyCustomContent)
   {
     ULONG blockedByABPPageSize = static_cast<ULONG>(g_blockedByABPPage.size());
     auto positionGrow = std::min<ULONG>(cb, static_cast<ULONG>(blockedByABPPageSize - m_currentPositionOfSentPage));
     if (positionGrow == 0) {
       return S_FALSE;
     }
     std::copy(g_blockedByABPPage.begin(), g_blockedByABPPage.begin() + positionGrow,
       stdext::make_checked_array_iterator(static_cast<char*>(pv), cb));
     *pcbRead = positionGrow;
     m_currentPositionOfSentPage += positionGrow;
@@ skipping 71 matching lines @@
   return false;
 }
 
 STDMETHODIMP WBPassthruSink::BeginningTransaction(LPCWSTR szURL, LPCWSTR szHeaders, DWORD dwReserved, LPWSTR* pszAdditionalHeaders)
 {
   if (!szURL)
   {
     return E_POINTER;
   }
   std::wstring src = szURL;
-  UnescapeUrl(src);
   DEBUG_GENERAL(src);
-
-  std::string acceptHeader = ExtractHttpAcceptHeader(m_spTargetProtocol);
 
   if (pszAdditionalHeaders)
   {
     *pszAdditionalHeaders = nullptr;
   }
 
   CComPtr<IHttpNegotiate> httpNegotiate;
   QueryServiceFromClient(&httpNegotiate);
   // This fills the pszAdditionalHeaders with more headers. One of which is the Referer header, which we need.
   // There doesn't seem to be any other way to get this header before the request has been made.
   HRESULT nativeHr = httpNegotiate ? httpNegotiate->BeginningTransaction(szURL, szHeaders, dwReserved, pszAdditionalHeaders) : S_OK;
 
   if (pszAdditionalHeaders && *pszAdditionalHeaders)
   {
     m_boundDomain = ExtractHttpHeader<std::wstring>(*pszAdditionalHeaders, L"Referer:", L"\n");
   }
   m_boundDomain = TrimString(m_boundDomain);
-  m_contentType = GetContentType(ATL::CString(acceptHeader.c_str()), m_boundDomain, src);
-
-  CPluginTab* tab = CPluginClass::GetTabCurrentThread();
+  m_contentType = InferContentType(ToUtf16String(ExtractHttpAcceptHeader(m_spTargetProtocol)), m_boundDomain, src);
+
+  CPluginTab* tab = CPluginClass::GetTabForCurrentThread();
   CPluginClient* client = CPluginClient::GetInstance();
 
   if (tab && client)
   {
     std::wstring documentUrl = tab->GetDocumentUrl();
     // Page is identical to document => don't block
     if (documentUrl == src)
     {
       return nativeHr;
     }
     else if (CPluginSettings::GetInstance()->IsPluginEnabled() && !client->IsWhitelistedUrl(documentUrl))
     {
       if (tab->IsFrameCached(src))
       {
         m_contentType = ContentType::CONTENT_TYPE_SUBDOCUMENT;
       }
     }
   }
 
   if (IsFlashRequest(pszAdditionalHeaders))
   {
     m_contentType = ContentType::CONTENT_TYPE_OBJECT_SUBREQUEST;
   }
 
   if (pszAdditionalHeaders && *pszAdditionalHeaders && IsXmlHttpRequest(*pszAdditionalHeaders))
   {
     m_contentType = ContentType::CONTENT_TYPE_XMLHTTPREQUEST;
   }
 
-  if (client->ShouldBlock(szURL, m_contentType, m_boundDomain, /*debug flag but must be set*/true))
+  if (client->ShouldBlock(src, m_contentType, m_boundDomain, /*debug flag but must be set*/true))
   {
     // NOTE: Feeding custom HTML to Flash, instead of original object subrequest
     // doesn't have much sense. It also can manifest in unwanted result
     // like video being blocked (See https://issues.adblockplus.org/ticket/1669)
     // So we report blocked object subrequests as failed, not just empty HTML.
     m_isCustomResponse = m_contentType != ContentType::CONTENT_TYPE_OBJECT_SUBREQUEST;
     return E_ABORT;
   }
   return nativeHr;
 }
@@ skipping 21 matching lines @@
   if (m_isCustomResponse)
   {
     // Don't notify the client about aborting of the operation, thus don't call BaseClass::ReportResult.
     // Current method is called by the original protocol implementation and we are intercepting the
     // call here and eating it, we will call the proper ReportResult later by ourself.
     return S_OK;
   }
   return BaseClass::ReportResult(hrResult, dwError, szResult);
 }
 
-
-WBPassthru::WBPassthru()
-  : m_shouldSupplyCustomContent(false)
-{
-}
-
-STDMETHODIMP WBPassthru::Start(LPCWSTR szUrl, IInternetProtocolSink *pOIProtSink,
+HRESULT WbPassthroughSinkStartPolicy::OnStart(LPCWSTR szUrl,
+  IInternetProtocolSink *pOIProtSink, IInternetBindInfo *pOIBindInfo,
+  DWORD grfPI, HANDLE_PTR dwReserved,
+  IInternetProtocol* pTargetProtocol)
+{
+  HRESULT hr = BaseClass::OnStart(szUrl, pOIProtSink, pOIBindInfo, grfPI, dwReserved, pTargetProtocol);
+  WBPassthruSink* pSink = GetSink();
+  if (hr == E_ABORT && pSink->m_isCustomResponse)
+  {
+    GetProtocol(pSink)->m_shouldSupplyCustomContent = true;
+    pSink->m_spInternetProtocolSink->ReportProgress(BINDSTATUS_MIMETYPEAVAILABLE, L"text/html");
+    pSink->m_spInternetProtocolSink->ReportData(BSCF_FIRSTDATANOTIFICATION, 0, static_cast<ULONG>(g_blockedByABPPage.size()));
+    return S_OK;
+  }
+  return hr;
+}
+
+STDMETHODIMP WbPassthroughProtocol::Start(LPCWSTR szUrl, IInternetProtocolSink *pOIProtSink,
     IInternetBindInfo *pOIBindInfo, DWORD grfPI, HANDLE_PTR dwReserved)
 {
   ATLASSERT(m_spInternetProtocol != 0);
   if (!m_spInternetProtocol)
   {
     return E_UNEXPECTED;
   }
 
   return OnStart(szUrl, pOIProtSink, pOIBindInfo, grfPI, dwReserved, m_spInternetProtocol);
 }
 
-STDMETHODIMP WBPassthru::Read(/* [in, out] */ void *pv,/* [in] */ ULONG cb,/* [out] */ ULONG *pcbRead)
+STDMETHODIMP WbPassthroughProtocol::Read(/* [in, out] */ void *pv,/* [in] */ ULONG cb,/* [out] */ ULONG *pcbRead)
 {
   WBPassthruSink* pSink = GetSink();
   return pSink->OnRead(pv, cb, pcbRead);
 }