Issue 3337 - Update adblockplus reference in libadblockplus to revision hg:813682c7161e

include/AdblockPlus/FilterEngine.h

 /*
  * This file is part of Adblock Plus <https://adblockplus.org/>,
  * 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
@@ skipping 15 matching lines @@
 #include <AdblockPlus/JsValue.h>
 #include <AdblockPlus/Notification.h>
 
 namespace AdblockPlus
 {
   class FilterEngine;
 
   /**
    * Wrapper for an Adblock Plus filter object.
    * There are no accessors for most
-   * [filter properties](https://adblockplus.org/jsdoc/adblockplus/symbols/Filter.html),
+   * [filter properties](https://adblockplus.org/jsdoc/adblockpluscore/Filter.html),
    * use `GetProperty()` to retrieve them by name.
    */
   class Filter : public JsValue,
                  public std::enable_shared_from_this<Filter>
   {
   public:
     /**
      * Filter types, see https://adblockplus.org/en/filters.
      */
     enum Type {TYPE_BLOCKING, TYPE_EXCEPTION,
@@ skipping 29 matching lines @@
      * Normally you shouldn't call this directly, but use
      * FilterEngine::GetFilter() instead.
      * @param value JavaScript filter object.
      */
     Filter(JsValuePtr value);
   };
 
   /**
    * Wrapper for a subscription object.
    * There are no accessors for most
-   * [subscription properties](https://adblockplus.org/jsdoc/adblockplus/symbols/Subscription.html),
+   * [subscription properties](https://adblockplus.org/jsdoc/adblockpluscore/Subscription.html),
    * use `GetProperty()` to retrieve them by name.
    */
   class Subscription : public JsValue,
                        public std::enable_shared_from_this<Subscription>
   {
   public:
     /**
      * Checks if this subscription has been added to the list of subscriptions.
      * @return `true` if this subscription has been added.
      */
@@ skipping 70 matching lines @@
       CONTENT_TYPE_XMLHTTPREQUEST = 2048,
       CONTENT_TYPE_OBJECT_SUBREQUEST = 4096,
       CONTENT_TYPE_MEDIA = 16384,
       CONTENT_TYPE_FONT = 32768,
       CONTENT_TYPE_GENERICBLOCK = 0x20000000,
       CONTENT_TYPE_ELEMHIDE = 0x40000000,
       CONTENT_TYPE_GENERICHIDE = 0x80000000
     };
 
     /**
+     * Bitmask of `ContentType` values.
+     * The underlying type is signed 32 bit integer because it is actually used
+     * in JavaScript where it is converted into 32 bit signed integer.
+     */
+    typedef int32_t ContentTypeMask;
+
+    /**
      * Callback type invoked when an update becomes available.
      * The parameter is the download URL of the update.
      */
     typedef std::function<void(const std::string&)> UpdateAvailableCallback;
 
     /**
      * Callback type invoked when a manually triggered update check finishes.
      * The parameter is an optional error message.
      */
     typedef std::function<void(const std::string&)> UpdateCheckDoneCallback;
 
     /**
      * Callback type invoked when the filters change.
      * The first parameter is the action event code (see
-     * [FilterNotifier.triggerListeners](https://adblockplus.org/jsdoc/adblockplus/symbols/FilterNotifier.html#.triggerListeners)
+     * [FilterNotifier.triggerListeners](https://adblockplus.org/jsdoc/adblockpluscore/FilterNotifier.html#.triggerListeners)
      * for the full list).
      * The second parameter is the filter/subscription object affected, if any.
      */
     typedef std::function<void(const std::string&, const JsValuePtr)> FilterChangeCallback;
 
     /**
      * Container of name-value pairs representing a set of preferences.
      */
     typedef std::map<std::string, AdblockPlus::JsValuePtr> Prefs;
 
@@ skipping 82 matching lines @@
      * @param url URL to match.
      * @param contentTypeMask Content type mask of the requested resource.
      * @param documentUrl URL of the document requesting the resource.
      *        Note that there will be more than one document if frames are
      *        involved, see
      *        Matches(const std::string&, const std::string&, const std::vector<std::string>&) const.
      * @return Matching filter, or `null` if there was no match.
      * @throw `std::invalid_argument`, if an invalid `contentType` was supplied.
      */
     FilterPtr Matches(const std::string& url,
-        int32_t contentTypeMask,

[Eric, 2016/02/09 15:43:03]

It would seem better to use uint32_t here, given that this type has turned into
something of a bit field.

Probably deserves a 'typedef' too, since the carrier type doesn't reflect the
semantics of a content type.

Also, calling them all "...Mask" is putting the type into the variable name.
While not against the explicit directives of our style guide, it's certainly
against the spirit of it. Better to put the type into the type name with a
'typedef'.

[sergei, 2016/02/09 17:15:47]

Yes, however it will be converted into signed integer by JavaScript, so it looks
fair to use signed integer here as well.
I have added the typedef.

+        ContentTypeMask contentTypeMask,
         const std::string& documentUrl) const;
 
     /**
      * Checks if any active filter matches the supplied URL.
      * @param url URL to match.
      * @param contentTypeMask Content type mask of the requested resource.
      * @param documentUrls Chain of documents requesting the resource, starting
      *        with the current resource's parent frame, ending with the
      *        top-level frame.
      *        If the application is not capable of identifying the frame
      *        structure, e.g. because it is a proxy, it can be approximated
      *        using `ReferrerMapping`.
      * @return Matching filter, or a `null` if there was no match.
      * @throw `std::invalid_argument`, if an invalid `contentType` was supplied.
      */
     FilterPtr Matches(const std::string& url,
-        int32_t contentTypeMask,
+        ContentTypeMask contentTypeMask,
         const std::vector<std::string>& documentUrls) const;
 
     /**
      * Checks whether the document at the supplied URL is whitelisted.
      * @param url URL of the document.
      * @param documentUrls Chain of document URLs requesting the document,
      *        starting with the current document's parent frame, ending with
      *        the top-level frame.
      *        If the application is not capable of identifying the frame
      *        structure, e.g. because it is a proxy, it can be approximated
@@ skipping 113 matching lines @@
 
   private:
     JsEnginePtr jsEngine;
     bool initialized;
     bool firstRun;
     int updateCheckId;
     static const std::map<ContentType, std::string> contentTypes;
 
     void InitDone(JsValueList& params);
     FilterPtr CheckFilterMatch(const std::string& url,
-                               int32_t contentTypeMask,
+                               ContentTypeMask contentTypeMask,
                                const std::string& documentUrl) const;
     void UpdateAvailable(UpdateAvailableCallback callback, JsValueList& params);
     void UpdateCheckDone(const std::string& eventName,
                          UpdateCheckDoneCallback callback, JsValueList& params);
     void FilterChanged(FilterChangeCallback callback, JsValueList& params);
     void ShowNotification(const ShowNotificationCallback& callback,
       const JsValueList& params);
     FilterPtr GetWhitelistingFilter(const std::string& url,
-      int32_t contentTypeMask, const std::string& documentUrl) const;
+      ContentTypeMask contentTypeMask, const std::string& documentUrl) const;
     FilterPtr GetWhitelistingFilter(const std::string& url,
-      int32_t contentTypeMask,
+      ContentTypeMask contentTypeMask,
       const std::vector<std::string>& documentUrls) const;
   };
 }
 
 #endif