core(iframe-elements): Include new IFrameElements gatherer

lighthouse-cli/test/cli/__snapshots__/index-test.js.snap

@@ -1144,6 +1144,9 @@ Object {
         Object {
           "path": "script-elements",
         },
+        Object {
+          "path": "iframe-elements",
+        },
         Object {
           "path": "dobetterweb/appcache",
         },

lighthouse-core/config/default-config.js

@@ -126,6 +126,7 @@ const defaultConfig = {
       'link-elements',
       'meta-elements',
       'script-elements',
+      'iframe-elements',
       'dobetterweb/appcache',
       'dobetterweb/doctype',
       'dobetterweb/domstats',

lighthouse-core/gather/gatherers/iframe-elements.js

@@ -0,0 +1,83 @@
+/**
+ * @license Copyright 2019 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
+ */
+'use strict';
+
+const Gatherer = require('./gatherer.js');
+const pageFunctions = require('../../lib/page-functions.js');
+
+/* eslint-env browser, node */
+
+/**
+ * @return {LH.Artifacts['IFrameElements']}
+ */
+/* istanbul ignore next */
+function collectIFrameElements() {
+  // @ts-ignore - put into scope via stringification
+  const iFrameElements = getElementsInDocument('iframe'); // eslint-disable-line no-undef
+  return iFrameElements.map(/** @param {HTMLIFrameElement} node */ (node) => {
+    const clientRect = node.getBoundingClientRect();
+    // Marking 1x1 as non-visible to ignore tracking pixels.
+
+    const {top, bottom, left, right, width, height} = clientRect;
+    return {
+      id: node.id,
+      src: node.src,
+      clientRect: {top, bottom, left, right, width, height},
+      pixelArea: width * height,
+      // @ts-ignore - put into scope via stringification
+      isPositionFixed: isPositionFixed(node), // eslint-disable-line no-undef
+    };
+  });
+}
+
+class IFrameElements extends Gatherer {
+  /**
+   * @param {LH.Gatherer.PassContext} passContext
+   * @return {Promise<LH.Artifacts['IFrameElements']>}
+   * @override
+   */
+  async afterPass(passContext) {
+    const driver = passContext.driver;
+
+    const {frameTree} = await driver.sendCommand('Page.getFrameTree');
+    const toVisit = [frameTree];
+    /** @type {Map<string | undefined, LH.Crdp.Page.Frame | null>} */
+    const framesByDomId = new Map();
+
+    while (toVisit.length) {
+      const tempFrameTree = toVisit.shift();
+      if (tempFrameTree) {
+        for (const childFrameTree of tempFrameTree.childFrames || []) {
+          if (childFrameTree.childFrames) {
+            toVisit.concat(childFrameTree.childFrames);
+          }
+          if (framesByDomId.has(childFrameTree.frame.name)) {
+            // DOM ID collision, mark it as null.
+            framesByDomId.set(childFrameTree.frame.name, null);
+          } else {
+            framesByDomId.set(childFrameTree.frame.name, childFrameTree.frame);
+          }
+        }
+      }
+    }
+
+    const expression = `(() => {
+      ${pageFunctions.getOuterHTMLSnippetString};
+      ${pageFunctions.getElementsInDocumentString};
+      ${pageFunctions.isPositionFixedString};
+      return (${collectIFrameElements})();
+    })()`;
+
+    /** @type {LH.Artifacts['IFrameElements']} */
+    const iframeElements = await driver.evaluateAsync(expression, {useIsolation: true});
+    for (const el of iframeElements) {
+      el.frame = framesByDomId.get(el.id);
+    }
+    return iframeElements;
+  }
+}
+
+module.exports = IFrameElements;

lighthouse-core/lib/page-functions.js

@@ -225,6 +225,55 @@ function getNodeSelector(node) {
   return parts.join(' > ');
 }
 
+/**
+ * This function checks if an element or an ancestor of an element is `position:fixed`.
+ * In addition we ensure that the element is capable of behaving as a `position:fixed`
+ * element, checking that it lives within a scrollable ancestor.
+ * @param {HTMLElement} element
+ * @return {boolean}
+ */
+/* istanbul ignore next */
+function isPositionFixed(element) {
+  /**
+   * @param {HTMLElement} element
+   * @return {boolean}
+   */
+  function hasScrollableAncestor(element) {
+    let currentEl = element.parentElement;
+    while (currentEl) {
+      if (currentEl.scrollHeight > currentEl.clientHeight) {
+        const yScroll = getStyleAttrValue(currentEl, 'overflowY');
+        if (yScroll) {
+          return true;
+        }
+      }
+      currentEl = currentEl.parentElement;
+    }
+    return false;
+  }
+
+  /**
+   * @param {HTMLElement} element
+   * @param {string} attr
+   * @return {string}
+   */
+  function getStyleAttrValue(element, attr) {
+    // Check style before computedStyle as computedStyle is expensive.
+    return element.style[attr] || window.getComputedStyle(element)[attr];
+  }
+
+  let currentEl = element;
+  while (currentEl) {
+    const position = getStyleAttrValue(currentEl, 'position');
+    // Only truly fixed if an ancestor is scrollable.
+    if ((position === 'fixed' || position === 'sticky') && hasScrollableAncestor(currentEl)) {
+      return true;
+    }
+    currentEl = currentEl.parentElement;
+  }
+  return false;
+}
+
 /**
  * Generate a human-readable label for the given element, based on end-user facing
  * strings like the innerText or alt attribute.
@@ -280,4 +329,5 @@ module.exports = {
   getNodeSelector: getNodeSelector,
   getNodeLabel: getNodeLabel,
   getNodeLabelString: getNodeLabel.toString(),
+  isPositionFixedString: isPositionFixed.toString(),
 };

types/artifacts.d.ts

@@ -61,6 +61,8 @@ declare global {
     export interface PublicGathererArtifacts {
       /** Console deprecation and intervention warnings logged by Chrome during page load. */
       ConsoleMessages: Crdp.Log.EntryAddedEvent[];
+      /** All the iframe elements in the page.*/
+      IFrameElements: Artifacts.IFrameElement[];
       /** Information on size and loading for all the images in the page. Natural size information for `picture` and CSS images is only available if the image was one of the largest 50 images. */
       ImageElements: Artifacts.ImageElement[];
       /** All the link elements on the page or equivalently declared in `Link` headers. @see https://html.spec.whatwg.org/multipage/links.html */
@@ -182,6 +184,28 @@ declare global {
         params: {name: string; value: string}[];
       }
 
+      export interface IFrameElement {
+        /** The `id` attribute of the iframe. */
+        id: string,
+        /** The `src` attribute of the iframe. */
+        src: string,
+        /** The iframe's ClientRect. @see https://developer.mozilla.org/en-US/docs/Web/API/Element/getBoundingClientRect */
+        clientRect: {
+          top: number;
+          bottom: number;
+          left: number;
+          right: number;
+          width: number;
+          height: number;
+        },
+        /** The pixel area iframe. */
+        pixelArea: number,
+        /** If the iframe or an ancestor of the iframe is fixed in position. */
+        isPositionFixed: boolean,
+        /** The Frame of the iframe. @see https://chromedevtools.github.io/devtools-protocol/tot/Page#type-Frame */
+        frame?: Crdp.Page.Frame | null,
+      }
+
       /** @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/link#Attributes */
       export interface LinkElement {
         /** The `rel` attribute of the link, normalized to lower case. @see https://developer.mozilla.org/en-US/docs/Web/HTML/Link_types */