Issue 581 - Fixed element hiding/collapsing in anonymous frames on Chrome

include.preload.js

 /*
  * This file is part of Adblock Plus <http://adblockplus.org/>,
  * Copyright (C) 2006-2014 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 47 matching lines @@
   }
 }
 
 function checkExceptionKey()
 {
   var attr = document.documentElement.getAttribute("data-adblockkey");
   if (attr)
     ext.backgroundPage.sendMessage({type: "add-key-exception", token: attr});
 }
 
+function hasInlineURL(element, attribute)
+{
+  var value = element.getAttribute(attribute);
+  return value == null || /^\s*(javascript:|about:|$)/i.test(value);
+}
+
+function isInlineFrame(element)
+{
+  switch (element.localName)
+  {
+    case "iframe":
+      return hasInlineURL(element, "src") || element.hasAttribute("srcdoc");
+    case "frame":
+      return hasInlineURL(element, "src");
+    case "object":
+      return hasInlineURL(element, "data") && element.contentDocument;
+    default:
+      return false;
+  }
+}
+
 // Converts relative to absolute URL
 // e.g.: foo.swf on http://example.com/whatever/bar.html
 //  -> http://example.com/whatever/foo.swf
 function relativeToAbsoluteUrl(url)
 {
   // If URL is already absolute, don't mess with it
   if (!url || /^[\w\-]+:/i.test(url))
     return url;
 
   // Leading / means absolute path
   // Leading // means network path
   if (url[0] == '/')
   {
     if (url[1] == '/')
       return document.location.protocol + url;
     else
       return document.location.protocol + "//" + document.location.host + url;
   }
 
   // Remove filename and add relative URL to it
   var base = document.baseURI.match(/.+\//);
   if (!base)
     return document.baseURI + "/" + url;
   return base[0] + url;
 }
 
 function init(document)
 {
+  var canUseShadow = "webkitCreateShadowRoot" in document.documentElement;
+  var fixInlineFrames = false;
+
+  var match = navigator.userAgent.match(/\bChrome\/(\d+)/);
+  if (match)
+  {
+    var chromeVersion = parseInt(match[1]);
+
+    // the <shadow> element is ignored in Chrome 32 (#309). Also Chrome 31-33
+    // crashes in some situations on some pages when using shadow DOM (#498).
+    // So we must not use Shadow DOM on those versions of Chrome.
+    if (chromeVersion >= 31 && chromeVersion <= 33)
+      canUseShadow = false;
+
+    // prior to Chrome 37, content scripts don't run on about:blank
+    // and about:srcdoc. So we have to apply element hiding and collapsing
+    // from the parent frame, when inline frames are loaded.
+    if (chromeVersion < 37)
+      fixInlineFrames = true;
+  }
+
   // use Shadow DOM if available to don't mess with web pages that
-  // rely on the order of their own <style> tags. However
-  // the <shadow> element is broken in some Chrome 32 builds (#309)
-  //
-  // also Chrome 31-33 crashes in some situations on some pages when using
-  // ShadowDOM, e.g. when pressing tab key on Wikipedia and Facebook (#498)
-  //
-  // also we must not create the shadow root in the response callback passed
-  // to sendMessage(), otherwise Chrome breaks some websites (#450)
-  var shadow = null;
-  if ("webkitCreateShadowRoot" in document.documentElement && !/\bChrome\/3[1-3]\b/.test(navigator.userAgent))
-  {
-    shadow = document.documentElement.webkitCreateShadowRoot();
+  // rely on the order of their own <style> tags (#309). However we
+  // must not create the shadow root in the response callback passed
+  // to sendMessage(), otherwise Chrome breaks some websites (#450).
+  if (canUseShadow)
+  {
+    var shadow = document.documentElement.webkitCreateShadowRoot();
     shadow.appendChild(document.createElement("shadow"));
   }
 
   // Sets the currently used CSS rules for elemhide filters
   var setElemhideCSSRules = function(selectors)
   {
     if (selectors.length == 0)
       return;
 
     var style = document.createElement("style");
     style.setAttribute("type", "text/css");
 
-    if (shadow)
+    if (canUseShadow)
     {
       shadow.appendChild(style);
 
       try
       {
         document.querySelector("::content");
 
         for (var i = 0; i < selectors.length; i++)
           selectors[i] = "::content " + selectors[i];
       }
@@ skipping 33 matching lines @@
     setRules();
   };
 
   document.addEventListener("error", function(event)
   {
     checkCollapse(event.target);
   }, true);
 
   document.addEventListener("load", function(event)
   {
-    if (/^i?frame$/.test(event.target.localName))
-    {
-      checkCollapse(event.target);
-
-      // Chrome doesn't run our content script on anonymous frames.
-      // So we have to apply element hiding and collapsing from the
-      // parent frame, when an anonymous sub frame loaded.
-      if (/^(javascript:|$)/.test(event.target.src) && /\bChrome\//.test(navigator.userAgent))
-      {
-        var contentDocument = event.target.contentDocument;
-
-        if (contentDocument.documentElement instanceof HTMLElement)
-        {
-          init(contentDocument);
-
-          for (tagName in typeMap)
-            Array.prototype.forEach.call(contentDocument.getElementsByTagName(tagName), checkCollapse);
-        }
-      }
+    var element = event.target;
+
+    if (/^i?frame$/.test(element.localName))
+      checkCollapse(element);
+
+    if (fixInlineFrames && isInlineFrame(element))
+    {
+      init(element.contentDocument);
+
+      for (var tagName in typeMap)
+        Array.prototype.forEach.call(element.contentDocument.getElementsByTagName(tagName), checkCollapse);
     }
   }, true);
 
   ext.backgroundPage.sendMessage({type: "get-selectors"}, setElemhideCSSRules);
 }
 
 if (document.documentElement instanceof HTMLElement)
 {
   checkExceptionKey();
   init(document);
 }