Issue 4864 - Start using ESLint for adblockpluschrome

chrome/ext/background.js

 /*
  * This file is part of Adblock Plus <https://adblockplus.org/>,
- * Copyright (C) 2006-2016 Eyeo GmbH
+ * Copyright (C) 2006-2017 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/>.
  */
 
 "use strict";
 
+(function()
 {
   /* Pages */
 
   let Page = ext.Page = function(tab)
   {
     this.id = tab.id;
     this._url = tab.url && new URL(tab.url);
 
     this.browserAction = new BrowserAction(tab.id);
     this.contextMenus = new ContextMenus(this);
@@ skipping 81 matching lines @@
     if (!frames)
       frames = framesOfTabs[tabId] = Object.create(null);
 
     let frame = frames[frameId];
     if (!frame)
       frame = frames[frameId] = {};
 
     return frame;
   }
 
-  chrome.webNavigation.onBeforeNavigate.addListener(details =>
-  {
-    // Capture parent frame here because onCommitted doesn't get this info.
-    let frame = createFrame(details.tabId, details.frameId);
-    frame.parent = framesOfTabs[details.tabId][details.parentFrameId] || null;
-  });
-
-  let eagerlyUpdatedPages = new ext.PageMap();
-
-  ext._updatePageFrameStructure = (frameId, tabId, url, eager) =>
+  function updatePageFrameStructure(frameId, tabId, url, parentFrameId)
   {
     if (frameId == 0)
     {
       let page = new Page({id: tabId, url});
 
-      if (eagerlyUpdatedPages.get(page) != url)
-      {
-        ext._removeFromAllPageMaps(tabId);
-
-        // When a sitekey header is received we must immediately update the page
-        // structure in order to record and use the key. We want to avoid
-        // trashing the page structure if the onCommitted event is then fired
-        // for the page.
-        if (eager)
-          eagerlyUpdatedPages.set(page, url);
-
-        chrome.tabs.get(tabId, () =>
-        {
-          // If the tab is prerendered, chrome.tabs.get() sets
-          // chrome.runtime.lastError and we have to dispatch the
-          // onLoading event, since the onUpdated event isn't
-          // dispatched for prerendered tabs.  However, we have to
-          // keep relying on the unUpdated event for tabs that are
-          // already visible. Otherwise browser action changes get
-          // overridden when Chrome automatically resets them on
-          // navigation.
-          if (chrome.runtime.lastError)
-            ext.pages.onLoading._dispatch(page);
-        });
-      }
-    }
-
-    // Update frame URL in frame structure
+      ext._removeFromAllPageMaps(tabId);
+
+      chrome.tabs.get(tabId, () =>
+      {
+        // If the tab is prerendered, chrome.tabs.get() sets
+        // chrome.runtime.lastError and we have to dispatch the onLoading event,
+        // since the onUpdated event isn't dispatched for prerendered tabs.
+        // However, we have to keep relying on the unUpdated event for tabs that
+        // are already visible. Otherwise browser action changes get overridden
+        // when Chrome automatically resets them on navigation.
+        if (chrome.runtime.lastError)
+          ext.pages.onLoading._dispatch(page);
+      });
+    }
+
+    // Update frame parent and URL in frame structure
     let frame = createFrame(tabId, frameId);
     frame.url = new URL(url);
-  };
-
-  chrome.webNavigation.onCommitted.addListener(details =>
-  {
-    ext._updatePageFrameStructure(details.frameId, details.tabId, details.url);
+    frame.parent = framesOfTabs[tabId][parentFrameId] || null;
+  }
+
+  chrome.webRequest.onHeadersReceived.addListener(details =>
+  {
+    // We have to update the frame structure when switching to a new
+    // document, so that we process any further requests made by that
+    // document in the right context. Unfortunately, we cannot rely
+    // on webNavigation.onCommitted since it isn't guaranteed to fire
+    // before any subresources start downloading[1]. As an
+    // alternative we use webRequest.onHeadersReceived for HTTP(S)
+    // URLs, being careful to ignore any responses that won't cause
+    // the document to be replaced.
+    // [1] - https://bugs.chromium.org/p/chromium/issues/detail?id=665843
+
+    // The request has been processed without replacing the document.
+    // https://chromium.googlesource.com/chromium/src/+/02d3f50b/content/browser/frame_host/navigation_request.cc#473
+    if (details.statusCode == 204 || details.statusCode == 205)
+      return;
+
+    for (let header of details.responseHeaders)
+    {
+      let headerName = header.name.toLowerCase();
+
+      // For redirects we must wait for the next response in order
+      // to know if the document will be replaced. Note: Chrome
+      // performs a redirect only if there is a "Location" header with
+      // a non-empty value and a known redirect status code.
+      // https://chromium.googlesource.com/chromium/src/+/39a7d96/net/http/http_response_headers.cc#929
+      if (headerName == "location" && header.value &&
+          (details.statusCode == 301 || details.statusCode == 302 ||
+           details.statusCode == 303 || details.statusCode == 307 ||
+           details.statusCode == 308))
+        return;
+
+      // If the response initiates a download the document won't be
+      // replaced. Chrome initiates a download if there is a
+      // "Content-Disposition" with a valid and non-empty value other
+      // than "inline".
+      // https://chromium.googlesource.com/chromium/src/+/02d3f50b/content/browser/loader/mime_sniffing_resource_handler.cc#534
+      // https://chromium.googlesource.com/chromium/src/+/02d3f50b/net/http/http_content_disposition.cc#374
+      // https://chromium.googlesource.com/chromium/src/+/16e2688e/net/http/http_util.cc#431
+      if (headerName == "content-disposition")
+      {
+        let disposition = header.value.split(";")[0].replace(/[ \t]+$/, "");
+        if (disposition.toLowerCase() != "inline" &&
+            /^[\x21-\x7E]+$/.test(disposition) &&
+            !/[()<>@,;:\\"/[\]?={}]/.test(disposition))
+          return;
+      }
+
+      // The value of the "Content-Type" header also determines if Chrome will
+      // initiate a download, or otherwise how the response will be rendered.
+      // We only need to consider responses which will result in a navigation
+      // and be rendered as HTML or similar.
+      // Note: Chrome might render the response as HTML if the "Content-Type"
+      // header is missing, invalid or unknown.
+      // https://chromium.googlesource.com/chromium/src/+/99f41af9/net/http/http_util.cc#66
+      // https://chromium.googlesource.com/chromium/src/+/3130418a/net/base/mime_sniffer.cc#667
+      if (headerName == "content-type")
+      {
+        let mediaType = header.value.split(/[ \t;(]/)[0].toLowerCase();
+        if (mediaType.includes("/") &&
+            mediaType != "*/*" &&
+            mediaType != "application/unknown" &&
+            mediaType != "unknown/unknown" &&
+            mediaType != "text/html" &&
+            mediaType != "text/xml" &&
+            mediaType != "application/xml" &&
+            mediaType != "application/xhtml+xml" &&
+            mediaType != "image/svg+xml")
+          return;
+      }
+    }
+
+    updatePageFrameStructure(details.frameId, details.tabId, details.url,
+                             details.parentFrameId);
+  },
+  {types: ["main_frame", "sub_frame"], urls: ["http://*/*", "https://*/*"]},
+  ["responseHeaders"]);
+
+  chrome.webNavigation.onBeforeNavigate.addListener(details =>
+  {
+    // Since we can only listen for HTTP(S) responses using
+    // webRequest.onHeadersReceived we must update the page structure here for
+    // other navigations.
+    let url = new URL(details.url);
+    if (url.protocol != "http:" && url.protocol != "https:")
+    {
+      updatePageFrameStructure(details.frameId, details.tabId, details.url,
+                               details.parentFrameId);
+    }
   });
 
   function forgetTab(tabId)
   {
     ext.pages.onRemoved._dispatch(tabId);
 
     ext._removeFromAllPageMaps(tabId);
     delete framesOfTabs[tabId];
   }
 
@@ skipping 192 matching lines @@
 
   /* Web requests */
 
   let framesOfTabs = Object.create(null);
 
   ext.getFrame = (tabId, frameId) =>
   {
     return (framesOfTabs[tabId] || {})[frameId];
   };
 
-  let handlerBehaviorChangedQuota = (
-    chrome.webRequest.MAX_HANDLER_BEHAVIOR_CHANGED_CALLS_PER_10_MINUTES
-  );
+  let handlerBehaviorChangedQuota =
+    chrome.webRequest.MAX_HANDLER_BEHAVIOR_CHANGED_CALLS_PER_10_MINUTES;
 
   function propagateHandlerBehaviorChange()
   {
     // Make sure to not call handlerBehaviorChanged() more often than allowed
     // by chrome.webRequest.MAX_HANDLER_BEHAVIOR_CHANGED_CALLS_PER_10_MINUTES.
     // Otherwise Chrome notifies the user that this extension is causing issues.
     if (handlerBehaviorChangedQuota > 0)
     {
       chrome.webNavigation.onBeforeNavigate.removeListener(
         propagateHandlerBehaviorChange
@@ skipping 74 matching lines @@
       let results = ext.webRequest.onBeforeRequest._dispatch(
         new URL(details.url),
         type.toUpperCase(),
         new Page({id: details.tabId}),
         frame
       );
 
       if (results.indexOf(false) != -1)
         return {cancel: true};
     }
-  }, {urls: ["http://*/*", "https://*/*"]}, ["blocking"]);
+  }, {urls: ["<all_urls>"]}, ["blocking"]);
 
 
   /* Message passing */
 
   chrome.runtime.onMessage.addListener((message, rawSender, sendResponse) =>
   {
     let sender = {};
 
     // Add "page" and "frame" if the message was sent by a content script.
     // If sent by popup or the background page itself, there is no "tab".
@@ skipping 11 matching lines @@
 
           let frame = frames[rawSender.frameId];
           if (frame)
             return frame.parent;
 
           return frames[0];
         }
       };
     }
 
-    let results = ext.onMessage._dispatch(message, sender, sendResponse);
-    return results.indexOf(true) != -1;
+    return ext.onMessage._dispatch(
+      message, sender, sendResponse
+    ).indexOf(true) != -1;
   });
 
 
   /* Storage */
 
   ext.storage = {
     get(keys, callback)
     {
       chrome.storage.local.get(keys, callback);
     },
@@ skipping 24 matching lines @@
       {
         chrome.runtime.openOptionsPage(() =>
         {
           if (chrome.runtime.lastError)
             return;
 
           chrome.tabs.query({active: true, lastFocusedWindow: true}, tabs =>
           {
             if (tabs.length > 0)
             {
-              window.setTimeout(() =>
-              {
+              if (tabs[0].status == "complete")
                 callback(new Page(tabs[0]));
-              });
+              else
+                afterTabLoaded(callback)(tabs[0]);
             }
           });
         });
       }
     };
   }
   else
   {
     // Edge does not yet support runtime.openOptionsPage (tested version 38)
     // and so this workaround needs to stay for now.
@@ skipping 34 matching lines @@
   /* Windows */
   ext.windows = {
     create(createData, callback)
     {
       chrome.windows.create(createData, createdWindow =>
       {
         afterTabLoaded(callback)(createdWindow.tabs[0]);
       });
     }
   };
-}
+}());