Issue 1282 - Don't generate filters conflicting with existing exception rules

include.postload.js

 /*
- * This file is part of Adblock Plus <http://adblockplus.org/>,
- * Copyright (C) 2006-2014 Eyeo GmbH
+ * 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
  * 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/>.
  */
 
 // Click-to-hide stuff
 var clickHide_activated = false;
 var clickHide_filters = null;
 var currentElement = null;
-var clickHideFilters = null;
 var highlightedElementsSelector = null;
 var clickHideFiltersDialog = null;
 var lastRightClickEvent = null;
-
-function escapeChar(chr)
-{
-  var code = chr.charCodeAt(0);
-
-  // Control characters and leading digits must be escaped based on
-  // their char code in CSS. Moreover, curly brackets aren't allowed
-  // in elemhide filters, and therefore must be escaped based on their
-  // char code as well.
-  if (code <= 0x1F || code == 0x7F || /[\d\{\}]/.test(chr))
-    return "\\" + code.toString(16) + " ";
-
-  return "\\" + chr;
-}
-
-function quote(value)
-{
-  return '"' + value.replace(/["\\\{\}\x00-\x1F\x7F]/g, escapeChar) + '"';
-}
-
-function escapeCSS(s)
-{
-  return s.replace(/^[\d\-]|[^\w\-\u0080-\uFFFF]/g, escapeChar);
-}
-
-function supportsShadowRoot(element)
-{
-  if (!("createShadowRoot" in element))
-    return false;
-
-  // There are some elements (e.g. <textarea>), which don't
-  // support author created shadow roots and throw an exception.
-  var clone = element.cloneNode(false);
-  try
-  {
-    clone.createShadowRoot();
-  }
-  catch (e)
-  {
-    return false;
-  }
-
-  // There are some elements (e.g. <input>), which support
-  // author created shadow roots, but ignore insertion points.
-  var child = document.createTextNode("");
-  clone.appendChild(child);
-
-  var shadow = document.createElement("shadow");
-  clone.shadowRoot.appendChild(shadow);
-
-  return shadow.getDistributedNodes()[0] == child;
-}
-
-function getOriginalStyle(element)
-{
-  if ("_originalStyle" in element)
-    return element._originalStyle;
-
-  return element.getAttribute("style");
-}
+var lastRightClickEventValid = false;
+var lastMouseOverEvent = null;
 
 function highlightElement(element, shadowColor, backgroundColor)
 {
   unhighlightElement(element);
 
-  var originalBoxShadowPriority = element.style.getPropertyPriority("box-shadow");
-  var originalBackgroundColorPriority = element.style.getPropertyPriority("background-color");
-
-  var boxShadow = "inset 0px 0px 5px " + shadowColor;
-
-  var highlightWithShadowDOM = function()
-  {
-    var style = document.createElement("style");
-    style.textContent = ":host {" +
-      "box-shadow:" + boxShadow + " !important;" +
-      "background-color:" + backgroundColor + " !important;" +
-    "}";
-
-    var root = element.createShadowRoot();
-    root.appendChild(document.createElement("shadow"));
-    root.appendChild(style);
+  var highlightWithOverlay = function()
+  {
+    var overlay = addElementOverlay(element);
+
+    // If the element isn't displayed no overlay will be added.
+    // Moreover, we don't need to highlight anything then.
+    if (!overlay)
+      return;
+
+    highlightElement(overlay, shadowColor, backgroundColor);
+    overlay.style.pointerEvents = "none";
 
     element._unhighlight = function()
     {
-      root.removeChild(style);
+      overlay.parentNode.removeChild(overlay);
     };
   };
 
   var highlightWithStyleAttribute = function()
   {
     var originalBoxShadow = element.style.getPropertyValue("box-shadow");
+    var originalBoxShadowPriority = element.style.getPropertyPriority("box-shadow");
     var originalBackgroundColor = element.style.getPropertyValue("background-color");
-
-    element._originalStyle = getOriginalStyle(element);
-
-    element.style.setProperty("box-shadow", boxShadow, "important");
+    var originalBackgroundColorPriority = element.style.getPropertyPriority("background-color");
+
+    element.style.setProperty("box-shadow", "inset 0px 0px 5px " + shadowColor, "important");
     element.style.setProperty("background-color", backgroundColor, "important");
 
     element._unhighlight = function()
     {
       this.style.removeProperty("box-shadow");
       this.style.setProperty(
         "box-shadow",
         originalBoxShadow,
         originalBoxShadowPriority
       );
 
       this.style.removeProperty("background-color");
       this.style.setProperty(
         "background-color",
         originalBackgroundColor,
         originalBackgroundColorPriority
       );
     };
   };
 
-  // Use shadow DOM if posibble to avoid side effects when the
-  // web page updates style while highlighted. However, if the
-  // element has important styles we can't override them with shadow DOM.
-  if (supportsShadowRoot(element) && originalBoxShadowPriority       != "important" &&
-                                     originalBackgroundColorPriority != "important")
-    highlightWithShadowDOM();
+  if ("prisoner" in element)
+    highlightWithStyleAttribute();
   else
-    highlightWithStyleAttribute();
+    highlightWithOverlay();
 }
 
 
 function unhighlightElement(element)
 {
   if ("_unhighlight" in element)
   {
     element._unhighlight();
     delete element._unhighlight;
   }
@@ skipping 22 matching lines @@
     );
 
     highlightedElementsSelector = null;
   }
 }
 
 function getURLsFromObjectElement(element)
 {
   var url = element.getAttribute("data");
   if (url)
-    return [resolveURL(url)];
+    return [url];
 
   for (var i = 0; i < element.children.length; i++)
   {
     var child = element.children[i];
     if (child.localName != "param")
       continue;
 
     var name = child.getAttribute("name");
     if (name != "movie"  && // Adobe Flash
         name != "source" && // Silverlight
         name != "src"    && // Real Media + Quicktime
         name != "FileName") // Windows Media
       continue;
 
     var value = child.getAttribute("value");
     if (!value)
       continue;
 
-    return [resolveURL(value)];
+    return [value];
   }
 
   return [];
 }
 
 function getURLsFromAttributes(element)
 {
   var urls = [];
 
   if (element.src)
     urls.push(element.src);
 
   if (element.srcset)
   {
     var candidates = element.srcset.split(",");
     for (var i = 0; i < candidates.length; i++)
     {
       var url = candidates[i].trim().replace(/\s+\S+$/, "");
       if (url)
-        urls.push(resolveURL(url));
+        urls.push(url);
     }
   }
 
   return urls;
 }
 
 function getURLsFromMediaElement(element)
 {
   var urls = getURLsFromAttributes(element);
 
@@ skipping 18 matching lines @@
 
     case "video":
     case "audio":
     case "picture":
       return getURLsFromMediaElement(element);
   }
 
   return getURLsFromAttributes(element);
 }
 
-// Gets the absolute position of an element by walking up the DOM tree,
-// adding up offsets.
-// I hope there's a better way because it just seems absolutely stupid
-// that the DOM wouldn't have a direct way to get this, given that it
-// has hundreds and hundreds of other methods that do random junk.
-function getAbsolutePosition(elt) {
-  var l = 0;
-  var t = 0;
-  for(; elt; elt = elt.offsetParent) {
-    l += elt.offsetLeft;
-    t += elt.offsetTop;
-  }
-  return [l, t];
-}
-
 // Adds an overlay to an element, which is probably a Flash object
-function addElementOverlay(elt, callback) {
-  // If this element is enclosed in an object tag, we prefer to block that instead
-  if(!elt)
-    return;
-
-  // If the element isn't rendered (since its or one of its ancestor's
-  // "display" property is "none"), the overlay wouldn't match the element.
-  if (!elt.offsetParent)
-    return;
-
-  generateFilters(elt, function(filters)
-  {
-    if (filters.length == 0)
-      return;
-
-    var thisStyle = getComputedStyle(elt, null);
-    var overlay = document.createElement('div');
-    overlay.prisoner = elt;
-    overlay.className = "__adblockplus__overlay";
-    overlay.setAttribute('style', 'opacity:0.4; background-color:#ffffff; display:inline-box; ' + 'width:' + thisStyle.width + '; height:' + thisStyle.height + '; position:absolute; overflow:hidden; -webkit-box-sizing:border-box;');
-    var pos = getAbsolutePosition(elt);
-    overlay.style.left = pos[0] + "px";
-    overlay.style.top = pos[1] + "px";
-
-    if (thisStyle.position != "static")
-      overlay.style.zIndex = thisStyle.zIndex;
-    else
-      overlay.style.zIndex = getComputedStyle(elt.offsetParent).zIndex;
-
-    document.body.appendChild(overlay);
-
-    if (callback)
-      callback(overlay);
-  });
+function addElementOverlay(elt) {
+  var zIndex = "auto";
+  var position = "absolute";
+
+  for (var e = elt; e; e = e.parentElement)
+  {
+    var style = getComputedStyle(e);
+
+    // If the element isn't rendered (since its or one of its ancestor's
+    // "display" property is "none"), the overlay wouldn't match the element.
+    if (style.display == "none")
+      return null;
+
+    // If the element or one of its ancestors uses fixed postioning, the overlay
+    // has to use fixed postioning too. Otherwise it might not match the element.
+    if (style.position == "fixed")
+      position = "fixed";
+
+    // Determine the effective z-index, which is the highest z-index used
+    // by the element and its offset ancestors, and increase it by one.
+    // When using a lower z-index the element would cover the overlay.
+    // When using a higher z-index the overlay might also cover other elements.
+    if (style.position != "static" && style.zIndex != "auto")
+    {
+      var curZIndex = parseInt(style.zIndex, 10) + 1;
+
+      if (zIndex == "auto" || curZIndex > zIndex)
+        zIndex = curZIndex;
+    }
+  }
+
+  var overlay = document.createElement('div');
+  overlay.prisoner = elt;
+  overlay.className = "__adblockplus__overlay";
+  overlay.setAttribute('style', 'opacity:0.4; display:inline-box; overflow:hidden; box-sizing:border-box;');
+  var rect = elt.getBoundingClientRect();
+  overlay.style.width = rect.width + "px";
+  overlay.style.height = rect.height + "px";
+  overlay.style.left = (rect.left + window.scrollX) + "px";
+  overlay.style.top = (rect.top + window.scrollY) + "px";
+  overlay.style.position = position;
+  overlay.style.zIndex = zIndex;
+
+  // elt.parentNode.appendChild(overlay, elt);
+  document.documentElement.appendChild(overlay);
+  return overlay;
 }
 
 // Show dialog asking user whether she wants to add the proposed filters derived
 // from selected page element
 function clickHide_showDialog(left, top, filters)
 {
   // If we are already selecting, abort now
   if (clickHide_activated || clickHideFiltersDialog)
     clickHide_deactivate(true);
 
   clickHide_filters = filters;
 
   clickHideFiltersDialog = document.createElement("iframe");
   clickHideFiltersDialog.src = ext.getURL("block.html");
   clickHideFiltersDialog.setAttribute("style", "position: fixed !important; visibility: hidden; display: block !important; border: 0px !important;");
   clickHideFiltersDialog.style.WebkitBoxShadow = "5px 5px 20px rgba(0,0,0,0.5)";
   clickHideFiltersDialog.style.zIndex = 0x7FFFFFFF;
 
   // Position in upper-left all the time
   clickHideFiltersDialog.style.left = "50px";
   clickHideFiltersDialog.style.top = "50px";
 
   // Make dialog partly transparent when mouse isn't over it so user has a better
   // view of what's going to be blocked
   clickHideFiltersDialog.onmouseout = function()
   {
     if (clickHideFiltersDialog)
       clickHideFiltersDialog.style.setProperty("opacity", "0.7");
-  }
+  };
   clickHideFiltersDialog.onmouseover = function()
   {
     if (clickHideFiltersDialog)
       clickHideFiltersDialog.style.setProperty("opacity", "1.0");
-  }
-
-  document.body.appendChild(clickHideFiltersDialog);
+  };
+
+  document.documentElement.appendChild(clickHideFiltersDialog);
 }
 
 // Turn on the choose element to create filter thing
 function clickHide_activate() {
   if(document == null)
     return;
 
   // If we are already selecting, abort now
   if (clickHide_activated || clickHideFiltersDialog)
     clickHide_deactivate();
 
-  // Add overlays for elements with URLs so user can easily click them
-  var elts = document.querySelectorAll('object,embed,img,iframe,video,audio,picture');
-  for(var i=0; i<elts.length; i++)
-    addElementOverlay(elts[i]);
+  // Add overlays for blockable elements that don't emit mouse events,
+  // so that they can still be selected.
+  [].forEach.call(
+    document.querySelectorAll('object,embed,iframe,frame'),
+    function(element)
+    {
+      getFiltersForElement(element, function(filters)
+      {
+        if (filters.length > 0)
+          addElementOverlay(element);
+      });
+    }
+  );
 
   clickHide_activated = true;
+  document.addEventListener("mousedown", clickHide_stopPropagation, true);
+  document.addEventListener("mouseup", clickHide_stopPropagation, true);
+  document.addEventListener("mouseenter", clickHide_stopPropagation, true);
+  document.addEventListener("mouseleave", clickHide_stopPropagation, true);
   document.addEventListener("mouseover", clickHide_mouseOver, true);
   document.addEventListener("mouseout", clickHide_mouseOut, true);
   document.addEventListener("click", clickHide_mouseClick, true);
   document.addEventListener("keydown", clickHide_keyDown, true);
+
+  ext.onExtensionUnloaded.addListener(clickHide_deactivate);
 }
 
 // Called when user has clicked on something and we are waiting for confirmation
 // on whether the user actually wants these filters
 function clickHide_rulesPending() {
   clickHide_activated = false;
+  document.removeEventListener("mousedown", clickHide_stopPropagation, true);
+  document.removeEventListener("mouseup", clickHide_stopPropagation, true);
+  document.removeEventListener("mouseenter", clickHide_stopPropagation, true);
+  document.removeEventListener("mouseleave", clickHide_stopPropagation, true);
   document.removeEventListener("mouseover", clickHide_mouseOver, true);
   document.removeEventListener("mouseout", clickHide_mouseOut, true);
   document.removeEventListener("click", clickHide_mouseClick, true);
   document.removeEventListener("keydown", clickHide_keyDown, true);
 }
 
 // Turn off click-to-hide
 function clickHide_deactivate(keepOverlays)
 {
   if (clickHideFiltersDialog)
   {
-    document.body.removeChild(clickHideFiltersDialog);
+    document.documentElement.removeChild(clickHideFiltersDialog);
     clickHideFiltersDialog = null;
   }
 
   clickHide_activated = false;
   clickHide_filters = null;
   if(!document)
     return; // This can happen inside a nuked iframe...I think
+
+  document.removeEventListener("mousedown", clickHide_stopPropagation, true);
+  document.removeEventListener("mouseup", clickHide_stopPropagation, true);
+  document.removeEventListener("mouseenter", clickHide_stopPropagation, true);
+  document.removeEventListener("mouseleave", clickHide_stopPropagation, true);
   document.removeEventListener("mouseover", clickHide_mouseOver, true);
   document.removeEventListener("mouseout", clickHide_mouseOut, true);
   document.removeEventListener("click", clickHide_mouseClick, true);
   document.removeEventListener("keydown", clickHide_keyDown, true);
 
-  if (!keepOverlays)
-  {
+  if (keepOverlays !== true)
+  {
+    lastRightClickEvent = null;
+
     if (currentElement) {
       currentElement.removeEventListener("contextmenu",  clickHide_elementClickHandler, true);
       unhighlightElements();
       unhighlightElement(currentElement);
       currentElement = null;
-      clickHideFilters = null;
     }
     unhighlightElements();
 
     var overlays = document.getElementsByClassName("__adblockplus__overlay");
     while (overlays.length > 0)
       overlays[0].parentNode.removeChild(overlays[0]);
-  }
-}
-
-function clickHide_elementClickHandler(ev) {
-  ev.preventDefault();
-  ev.stopPropagation();
-  clickHide_mouseClick(ev);
+
+    ext.onExtensionUnloaded.removeListener(clickHide_deactivate);
+  }
+}
+
+function clickHide_stopPropagation(e)
+{
+  e.stopPropagation();
+}
+
+function clickHide_elementClickHandler(e) {
+  e.preventDefault();
+  e.stopPropagation();
+  clickHide_mouseClick(e);
 }
 
 function getBlockableElementOrAncestor(element, callback)
 {
-  if (element && element != document.documentElement
-              && element != document.body)
-  {
-    generateFilters(element, function(filters)
-    {
-      if (filters.length > 0)
-        callback(element);
-      else
-        getBlockableElementOrAncestor(element.parentElement, callback);
-    });
-  }
-  else
-  {
-    callback(null);
-  }
+  // We assume that the user doesn't want to block the whole page.
+  // So we never consider the <html> or <body> element.
+  while (element && element != document.documentElement
+                 && element != document.body)
+  {
+    // We can't handle non-HTML (like SVG) elements, as well as
+    // <area> elements (see below). So fall back to the parent element.
+    if (!(element instanceof HTMLElement) || element.localName == "area")
+      element = element.parentElement;
+
+    // If image maps are used mouse events occur for the <area> element.
+    // But we have to block the image associated with the <map> element.
+    else if (element.localName == "map")
+    {
+      var images = document.querySelectorAll("img[usemap]");
+      var image = null;
+
+      for (var i = 0; i < images.length; i++)
+      {
+        var usemap = image.getAttribute("usemap");
+        var index = usemap.indexOf("#");
+
+        if (index != -1 && usemap.substr(index + 1) == element.name)
+        {
+          image = images[i];
+          break;
+        }
+      }
+
+      element = image;
+    }
+
+    // Finally, if none of the above is true, check whether we can generate
+    // any filters for this element. Otherwise fall back to its parent element.
+    else
+    {
+      getFiltersForElement(element, function(filters)
+      {
+        if (filters.length > 0)
+          callback(element);
+        else
+          getBlockableElementOrAncestor(element.parentElement, callback);
+      });
+
+      return;
+    }
+  }
+
+  // We reached the document root without finding a blockable element.
+  callback(null);
 }
 
 // Hovering over an element so highlight it
 function clickHide_mouseOver(e)
 {
-  if (clickHide_activated == false)
-    return;
+  lastMouseOverEvent = e;
 
   getBlockableElementOrAncestor(e.target, function(element)
   {
-    if (currentElement)
-      unhighlightElement(currentElement);
-
-    if (element)
-    {
-      highlightElement(element, "#d6d84b", "#f8fa47");
-      element.addEventListener("contextmenu", clickHide_elementClickHandler, true);
-    }
-
-    currentElement = element;
+    if (e == lastMouseOverEvent)
+    {
+      lastMouseOverEvent = null;
+
+      if (clickHide_activated)
+      {
+        if (currentElement)
+          unhighlightElement(currentElement);
+
+        if (element)
+        {
+          highlightElement(element, "#d6d84b", "#f8fa47");
+          element.addEventListener("contextmenu", clickHide_elementClickHandler, true);
+        }
+
+        currentElement = element;
+      }
+    }
   });
+
+  e.stopPropagation();
 }
 
 // No longer hovering over this element so unhighlight it
 function clickHide_mouseOut(e)
 {
   if (!clickHide_activated || currentElement != e.target)
     return;
 
   unhighlightElement(currentElement);
   currentElement.removeEventListener("contextmenu", clickHide_elementClickHandler, true);
+  e.stopPropagation();
 }
 
 // Selects the currently hovered-over filter or cancels selection
 function clickHide_keyDown(e)
 {
   if (!e.ctrlKey && !e.altKey && !e.shiftKey && e.keyCode == 13 /*DOM_VK_RETURN*/)
      clickHide_mouseClick(e);
   else if (!e.ctrlKey && !e.altKey && !e.shiftKey && e.keyCode == 27 /*DOM_VK_ESCAPE*/)
   {
     ext.backgroundPage.sendMessage(
     {
       type: "forward",
       payload:
       {
         type: "clickhide-deactivate"
       }
     });
     e.preventDefault();
     e.stopPropagation();
   }
 }
 
-function generateFilters(element, callback)
-{
-  function addStyleAttributeFilter(filters, selectors)
-  {
-    var style = getOriginalStyle(element);
-    if (style && filters.length == 0)
-    {
-      ext.backgroundPage.sendMessage(
-        {
-          type: "get-filters-from-selectors",
-          selectors: [escapeCSS(element.localName) + '[style=' + quote(style) + ']']
-        },
-
-        function(response)
-        {
-          callback(response.filters, response.selectors);
-        }
-      );
-    }
-    else
-      callback(filters, selectors);
-  }
-
-  function addElemHideFilters(filters, selectors)
-  {
-    if (selectors.length > 0)
-    {
-      ext.backgroundPage.sendMessage(
-        {
-          type: "get-filters-from-selectors",
-          selectors: selectors
-        },
-
-        function(response)
-        {
-          addStyleAttributeFilter(filters.concat(response.filters), response.selectors);
-        }
-      );
-    }
-    else
-      addStyleAttributeFilter(filters, selectors);
-  }
-
-  var filters = [];
-  var selectors = [];
-
-  if (element.id)
-    selectors.push("#" + escapeCSS(element.id));
-
-  if (element.classList.length > 0)
-  {
-    var selector = "";
-
-    for (var i = 0; i < element.classList.length; i++)
-      selector += "." + escapeCSS(element.classList[i]);
-
-    selectors.push(selector);
-  }
-
-  var urls = getURLsFromElement(element);
-  if (urls.length > 0)
-  {
-    ext.backgroundPage.sendMessage(
-      {
-        type: "check-whitelisted-urls",
-        mediatype: typeMap[element.localName],
-        urls: urls
-      },
-
-      function(whitelisted)
-      {
-        for (var i = 0; i < urls.length; i++)
-        {
-          var url = urls[i];
-
-          if (!whitelisted[url] && /^https?:/i.test(url))
-          {
-            var filter = url.replace(/^[\w\-]+:\/+(?:www\.)?/, "||");
-
-            if (filters.indexOf(filter) == -1)
-              filters.push(filter);
-
-            continue;
-          }
-
-          if (url == element.src)
-          {
-            var selector = escapeCSS(element.localName) + '[src=' + quote(element.getAttribute("src")) + ']';
-
-            if (selectors.indexOf(selector) == -1)
-              selectors.push(selector);
-          }
-        }
-
-        addElemHideFilters(filters, selectors);
-      }
-    );
-  }
-  else
-    addElemHideFilters(filters, selectors);
+function getFiltersForElement(element, callback)
+{
+  ext.backgroundPage.sendMessage(
+    {
+      type: "compose-filters",
+      tagName: element.localName,
+      id: element.id,
+      src: element.getAttribute("src"),
+      style: element.getAttribute("style"),
+      classes: [].slice.call(element.classList),
+      urls: getURLsFromElement(element),
+      mediatype: typeMap[element.localName],
+      baseURL: document.location.href
+    },
+    function(response)
+    {
+      callback(response.filters, response.selectors);
+    }
+  );
 }
 
 // When the user clicks, the currentElement is the one we want.
 // We should have ABP rules ready for when the
 // popup asks for them.
 function clickHide_mouseClick(e)
 {
   if (!currentElement || !clickHide_activated)
     return;
 
   var elt = currentElement;
   if (currentElement.classList.contains("__adblockplus__overlay"))
     elt = currentElement.prisoner;
 
-  generateFilters(elt, function(filters, selectors)
-  {
-    clickHide_showDialog(e.clientX, e.clientY, filters);
-
-    // Highlight the elements specified by selector in yellow
+  getFiltersForElement(elt, function(filters, selectors)
+  {
+    ext.backgroundPage.sendMessage(
+    {
+      type: "forward",
+      payload:
+      {
+        type: "clickhide-show-dialog",
+        screenX: e.screenX,
+        screenY: e.screenY,
+        clickHideFilters: filters
+      }
+    });
+
     if (selectors.length > 0)
       highlightElements(selectors.join(","));
 
-    // Now, actually highlight the element the user clicked on in red
     highlightElement(currentElement, "#fd1708", "#f6a1b5");
   });
 
   // Make sure the browser doesn't handle this click
   e.preventDefault();
   e.stopPropagation();
 }
 
 // This function Copyright (c) 2008 Jeni Tennison, from jquery.uri.js
 // and licensed under the MIT license. See jquery-*.min.js for details.
@@ skipping 27 matching lines @@
 // In Chrome 37-40, the document_end content script (this one) runs properly, while the
 // document_start content scripts (that defines ext) might not. Check whether variable ext
 // exists before continuing to avoid "Uncaught ReferenceError: ext is not defined".
 // See https://crbug.com/416907
 if ("ext" in window && document instanceof HTMLDocument)
 {
   // Use a contextmenu handler to save the last element the user right-clicked on.
   // To make things easier, we actually save the DOM event.
   // We have to do this because the contextMenu API only provides a URL, not the actual
   // DOM element.
-  document.addEventListener('contextmenu', function(e) {
+  document.addEventListener('contextmenu', function(e)
+  {
     lastRightClickEvent = e;
+    // We also need to ensure any old lastRightClickEvent variables in other
+    // frames are cleared.
+    lastRightClickEventValid = true;
+    ext.backgroundPage.sendMessage(
+    {
+      type: "forward",
+      payload:
+      {
+        type: "clickhide-clear-last-right-click-event"
+      }
+    });
   }, true);
 
   document.addEventListener("click", function(event)
   {
     // Ignore right-clicks
     if (event.button == 2)
       return;
 
     // Search the link associated with the click
     var link = event.target;
@@ skipping 59 matching lines @@
         break;
       case "clickhide-activate":
         clickHide_activate();
         break;
       case "clickhide-deactivate":
         clickHide_deactivate();
         break;
       case "clickhide-new-filter":
         if(lastRightClickEvent)
         {
-          var event = lastRightClickEvent;
-
-          addElementOverlay(event.target, function(overlay)
+          getBlockableElementOrAncestor(lastRightClickEvent.target, function(element)
           {
             clickHide_activated = true;
-            currentElement = overlay;
-            clickHide_mouseClick(event);
+            currentElement = element;
+            clickHide_mouseClick(lastRightClickEvent);
           });
         }
         break;
       case "clickhide-init":
         if (clickHideFiltersDialog)
         {
           sendResponse({filters: clickHide_filters});
 
           clickHideFiltersDialog.style.width = msg.width + "px";
           clickHideFiltersDialog.style.height = msg.height + "px";
           clickHideFiltersDialog.style.visibility = "visible";
         }
         break;
       case "clickhide-move":
         if (clickHideFiltersDialog)
         {
           clickHideFiltersDialog.style.left = (parseInt(clickHideFiltersDialog.style.left, 10) + msg.x) + "px";
           clickHideFiltersDialog.style.top = (parseInt(clickHideFiltersDialog.style.top, 10) + msg.y) + "px";
         }
         break;
       case "clickhide-close":
-        if (clickHideFiltersDialog && msg.remove)
+        if (currentElement && msg.remove)
         {
           // Explicitly get rid of currentElement
           var element = currentElement.prisoner || currentElement;
           if (element && element.parentNode)
             element.parentNode.removeChild(element);
         }
         clickHide_deactivate();
         break;
-      default:
-        sendResponse({});
+      case "clickhide-show-dialog":
+        if (window.self == window.top)
+          clickHide_showDialog(msg.screenX + window.pageXOffset,
+                               msg.screenY + window.pageYOffset,
+                               msg.clickHideFilters);
+        break;
+      case "clickhide-clear-last-right-click-event":
+        if (lastRightClickEventValid)
+          lastRightClickEventValid = false;
+        else
+          lastRightClickEvent = null;
         break;
     }
   });
 
   if (window == window.top)
     ext.backgroundPage.sendMessage({type: "report-html-page"});
 }