Consider the frame structure in Matches()

src/FilterEngine.cpp

 /*
  * This file is part of Adblock Plus <http://adblockplus.org/>,
  * Copyright (C) 2006-2013 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 197 matching lines @@
   std::vector<SubscriptionPtr> result;
   for (JsValueList::iterator it = values.begin(); it != values.end(); it++)
     result.push_back(SubscriptionPtr(new Subscription(*it)));
   return result;
 }
 
 AdblockPlus::FilterPtr FilterEngine::Matches(const std::string& url,
     const std::string& contentType,
     const std::string& documentUrl) const
 {
+  std::vector<std::string> documentUrls;
+  documentUrls.push_back(documentUrl);
+  return Matches(url, contentType, documentUrls);
+}
+
+AdblockPlus::FilterPtr FilterEngine::Matches(const std::string& url,
+    const std::string& contentType,
+    const std::vector<std::string>& documentUrls) const
+{
+  if (documentUrls.empty())
+    return CheckFilterMatch(url, contentType, "");
+
+  std::string lastDocumentUrl = documentUrls.front();
+  for (std::vector<std::string>::const_iterator it = documentUrls.begin();
+       it != documentUrls.end(); it++) {
+    const std::string documentUrl = *it;
+    AdblockPlus::FilterPtr match = CheckFilterMatch(documentUrl, "DOCUMENT",
+                                                    lastDocumentUrl);
+    if (match && match->GetType() == AdblockPlus::Filter::TYPE_EXCEPTION)
+      return match;
+    lastDocumentUrl = documentUrl;
+  }
+
+  return CheckFilterMatch(url, contentType, lastDocumentUrl);
+}
+
+AdblockPlus::FilterPtr FilterEngine::CheckFilterMatch(const std::string& url,
+    const std::string& contentType,
+    const std::string& documentUrl) const
+{
   JsValuePtr func = jsEngine->Evaluate("API.checkFilterMatch");
   JsValueList params;
   params.push_back(jsEngine->NewValue(url));
   params.push_back(jsEngine->NewValue(contentType));
   params.push_back(jsEngine->NewValue(documentUrl));
   JsValuePtr result = func->Call(params);
   if (!result->IsNull())
     return FilterPtr(new Filter(result));
   else
     return FilterPtr();
 }
 
-AdblockPlus::FilterPtr FilterEngine::Matches(const std::string& url,
-    const std::string& contentType,
-    const std::vector<std::string>& documentUrls) const
-{
-  AdblockPlus::FilterPtr match;
-  for (std::vector<std::string>::const_iterator it = documentUrls.begin();
-       it != documentUrls.end(); it++) {
-    match = Matches(url, contentType, *it);
-    if (!match || match->GetType() == AdblockPlus::Filter::TYPE_EXCEPTION)
-      return match;
-  }

[Wladimir Palant, 2013/10/30 07:39:56]

No, this approach is wrong - and it seems that we completely forgot to consider
exception rules properly in libadblockplus. There are exceptions that apply to
the particular request URL - and there are those that apply to the frame of that
URL. We need to check the latter first because they will override any blocking
rules for the URL. The approach should be the following:

For each documentUrl in documentUrl call API.checkFilterMatch. The type
parameter should be set to DOCUMENT and documentUrl parameter should be set to
the previous document URL (the frame that's one level higher). For the top-level
frame the URL and document URL parameters will be identical. If any of the
checks return an exception rule then that match should be returned.

Finally, API.checkFilterMatch should be called with the current parameters - the
URL of the request and the URL of the immediate frame that requested it (the
last one in the list I guess). Whatever we get from that call should be
returned.

Feel free to have a look at the checkRequest() function in
adblockpluschrome/webRequest.js if you need inspiration. Note that it makes
sense to have the "old" Matches method call this one with a single-element
vector.

[Felix Dahlke, 2013/11/03 03:51:15]

I was actually wondering about this after seeing pretty much that logic in
Policy.processNode in ABP for Firefox. Thought it was already taken care of at a
deeper level though.

So that's kind of a big improvement then: We can now support domain-based
whitelisting in Android :)

-  return match;
-}
-
 std::vector<std::string> FilterEngine::GetElementHidingSelectors(const std::string& domain) const
 {
   JsValuePtr func = jsEngine->Evaluate("API.getElementHidingSelectors");
   JsValueList params;
   params.push_back(jsEngine->NewValue(domain));
   JsValueList result = func->Call(params)->AsList();
   std::vector<std::string> selectors;
   for (JsValueList::iterator it = result.begin(); it != result.end(); ++it)
     selectors.push_back((*it)->AsString());
   return selectors;
@@ skipping 48 matching lines @@
 {
   jsEngine->RemoveEventCallback("filterChange");
 }
 
 void FilterEngine::FilterChanged(FilterEngine::FilterChangeCallback callback, JsValueList& params)
 {
   std::string action(params.size() >= 1 && !params[0]->IsNull() ? params[0]->AsString() : "");
   JsValuePtr item(params.size() >= 2 ? params[1] : jsEngine->NewValue(false));
   callback(action, item);
 }