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
-  );

[Sebastian Noack, 2017/02/09 01:04:49]

The parenthesis here seem unnecessary.

[kzar, 2017/02/20 10:27:29]

Done.

+  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

[Sebastian Noack, 2017/02/09 01:04:49]

I wonder whether we can perhaps shorten the variable name, rather than awkwardly
wrapping those lines. The variable name can be up to 19 characters in order to
avoid exceeding 80 characters total.

[kzar, 2017/02/20 10:27:28]

I don't mind the wrapping too much here and I can't think of a better name. But
I don't mind changing the name if you can think of something shorter either.

       );
       chrome.webRequest.handlerBehaviorChanged();
 
       handlerBehaviorChangedQuota--;
       setTimeout(() => { handlerBehaviorChangedQuota++; }, 600000);
     }
   }
 
   ext.webRequest = {
     onBeforeRequest: new ext._EventTarget(),
@@ skipping 64 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;

[Sebastian Noack, 2017/02/09 01:04:48]

This would be another way to wrap the code here, without a temporary variable:

  return ext.onMessage._dispatch(message,
                                 sender,
                                 sendResponse).indexOf(true) != -1;

No strong opinion though. What do you think?

[kzar, 2017/02/20 10:27:29]

I've wrapped it in a similar way which I preferred, that OK?

+    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]);
       });
     }
   };
-}
+}());