Backed out 12 changesets (bug 1493563) for failures in test_css-logic-getCssPath.html CLOSED TREE
authorNoemi Erli <nerli@mozilla.com>
Fri, 28 Sep 2018 21:31:18 +0300
changeset 494530 1681bd622c63ad7cf045cb70d487e0b538564d3f
parent 494529 3a5aa4e939536f27d4f3be418dd5e3e7bbe9130a
child 494531 059af370e80e62ad27048202a9d35b1c84ddc334
push id9984
push userffxbld-merge
push dateMon, 15 Oct 2018 21:07:35 +0000
treeherdermozilla-beta@183d27ea8570 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
bugs1493563
milestone64.0a1
backs outd2e83655082f82409ef48e97d9fac1cb4e76a606
1ce58f0045933cfa698ffed60d9792b76614c47b
344298c73ee77f8e003717fad204e1cbb6da13eb
02b8b073f7d7007ce41c2fb71aab5ceafe5d371b
3ef707008502d3555d384f8803b97d4b4c7a0d55
bb2720a401fed1848e792b202d744171a60af7d5
ce0211be57a17fc1568f7b668d612a142014ff39
83d6c2bf8dc6cd3b33ce25c5ac54fab8a391cf30
1844af4cc25bf57c2ec0f087cb132e69fb6f880b
c8ab17addb7a545f3e16588ef373a3dc496b78b5
a1ff0cd6256391045da570fd8f48eeaf27b6c443
932b41e211e04744ced36241c7469356f552a0bd
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Backed out 12 changesets (bug 1493563) for failures in test_css-logic-getCssPath.html CLOSED TREE Backed out changeset d2e83655082f (bug 1493563) Backed out changeset 1ce58f004593 (bug 1493563) Backed out changeset 344298c73ee7 (bug 1493563) Backed out changeset 02b8b073f7d7 (bug 1493563) Backed out changeset 3ef707008502 (bug 1493563) Backed out changeset bb2720a401fe (bug 1493563) Backed out changeset ce0211be57a1 (bug 1493563) Backed out changeset 83d6c2bf8dc6 (bug 1493563) Backed out changeset 1844af4cc25b (bug 1493563) Backed out changeset c8ab17addb7a (bug 1493563) Backed out changeset a1ff0cd62563 (bug 1493563) Backed out changeset 932b41e211e0 (bug 1493563)
accessible/base/DocManager.cpp
browser/base/content/browser-contentblocking.js
browser/base/content/browser.js
browser/base/content/tabbrowser.js
browser/base/content/test/general/browser_alltabslistener.js
browser/components/extensions/parent/ext-tabs.js
browser/components/shell/nsMacShellService.cpp
docshell/base/nsDocShell.cpp
docshell/base/nsDocShellTreeOwner.cpp
dom/base/ContentBlockingLog.h
dom/base/moz.build
dom/base/nsDocument.cpp
dom/base/nsGlobalWindowOuter.cpp
dom/base/nsGlobalWindowOuter.h
dom/base/nsIDocument.h
dom/base/nsPIDOMWindow.h
dom/browser-element/BrowserElementChildPreload.js
dom/clients/manager/ClientNavigateOpChild.cpp
dom/clients/manager/ClientOpenWindowUtils.cpp
dom/html/HTMLFormElement.cpp
dom/html/nsHTMLDNSPrefetch.cpp
dom/presentation/PresentationCallbacks.cpp
dom/security/nsMixedContentBlocker.cpp
dom/workers/test/mochitest.ini
editor/composer/nsEditingSession.cpp
editor/composer/test/test_bug434998.xul
editor/libeditor/tests/test_bug607584.xul
editor/libeditor/tests/test_bug616590.xul
editor/libeditor/tests/test_bug780908.xul
layout/base/tests/chrome/printpreview_bug396024_helper.xul
layout/base/tests/chrome/printpreview_bug482976_helper.xul
layout/base/tests/chrome/printpreview_helper.xul
layout/printing/ipc/RemotePrintJobChild.cpp
layout/printing/nsPrintJob.cpp
layout/tools/layout-debug/ui/content/layoutdebug.js
mobile/android/chrome/content/browser.js
mobile/android/modules/geckoview/GeckoViewProgress.jsm
mobile/android/modules/geckoview/GeckoViewTrackingProtection.jsm
modules/libpref/init/StaticPrefList.h
netwerk/base/nsChannelClassifier.cpp
netwerk/base/nsISecureBrowserUI.idl
netwerk/base/nsISecurityEventSink.idl
security/manager/ssl/nsSecureBrowserUIImpl.cpp
security/manager/ssl/nsSecureBrowserUIImpl.h
toolkit/actors/PrintingChild.jsm
toolkit/components/antitracking/AntiTrackingCommon.cpp
toolkit/components/antitracking/test/browser/browser_onModifyRequestNotificationForTrackingResources.js
toolkit/components/antitracking/test/browser/head.js
toolkit/components/browser/nsWebBrowser.cpp
toolkit/components/printing/content/printPreviewProgress.js
toolkit/components/printing/content/printProgress.js
toolkit/components/printingui/ipc/PrintProgressDialogChild.cpp
toolkit/components/printingui/nsPrintProgress.cpp
toolkit/components/printingui/nsPrintingPromptService.cpp
toolkit/components/statusfilter/nsBrowserStatusFilter.cpp
toolkit/components/url-classifier/tests/mochitest/test_threathit_report.html
toolkit/modules/RemoteSecurityUI.jsm
toolkit/modules/RemoteWebProgress.jsm
toolkit/modules/WebProgressChild.jsm
toolkit/mozapps/downloads/nsHelperAppDlg.js
toolkit/mozapps/extensions/content/extensions.js
uriloader/base/nsDocLoader.cpp
uriloader/base/nsIWebProgressListener.idl
uriloader/prefetch/nsOfflineCacheUpdateService.cpp
uriloader/prefetch/nsPrefetchService.cpp
xpfe/appshell/nsChromeTreeOwner.cpp
xpfe/appshell/nsWebShellWindow.cpp
--- a/accessible/base/DocManager.cpp
+++ b/accessible/base/DocManager.cpp
@@ -339,19 +339,17 @@ DocManager::OnStatusChange(nsIWebProgres
 {
   MOZ_ASSERT_UNREACHABLE("notification excluded in AddProgressListener(...)");
   return NS_OK;
 }
 
 NS_IMETHODIMP
 DocManager::OnSecurityChange(nsIWebProgress* aWebProgress,
                              nsIRequest* aRequest,
-                             uint32_t aOldState,
-                             uint32_t aState,
-                             const nsAString& aContentBlockingLogJSON)
+                             uint32_t aState)
 {
   MOZ_ASSERT_UNREACHABLE("notification excluded in AddProgressListener(...)");
   return NS_OK;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // nsIDOMEventListener
 
--- a/browser/base/content/browser-contentblocking.js
+++ b/browser/base/content/browser-contentblocking.js
@@ -459,18 +459,17 @@ var ContentBlocking = {
 
   shieldHistogramAdd(value) {
     if (PrivateBrowsingUtils.isWindowPrivate(window)) {
       return;
     }
     Services.telemetry.getHistogramById("TRACKING_PROTECTION_SHIELD").add(value);
   },
 
-  onSecurityChange(oldState, state, webProgress, isSimulated,
-                   contentBlockingLogJSON) {
+  onSecurityChange(state, webProgress, isSimulated) {
     let baseURI = this._baseURIForChannelClassifier;
 
     // Don't deal with about:, file: etc.
     if (!baseURI) {
       this.iconBox.removeAttribute("animate");
       this.iconBox.removeAttribute("active");
       this.iconBox.removeAttribute("hasException");
       return;
--- a/browser/base/content/browser.js
+++ b/browser/base/content/browser.js
@@ -4984,18 +4984,17 @@ var XULBrowserWindow = {
   _lastLocation: null,
 
   // This is called in multiple ways:
   //  1. Due to the nsIWebProgressListener.onSecurityChange notification.
   //  2. Called by tabbrowser.xml when updating the current browser.
   //  3. Called directly during this object's initializations.
   // aRequest will be null always in case 2 and 3, and sometimes in case 1 (for
   // instance, there won't be a request when STATE_BLOCKED_TRACKING_CONTENT is observed).
-  onSecurityChange(aWebProgress, aRequest, aOldState, aState,
-                   aContentBlockingLogJSON, aIsSimulated) {
+  onSecurityChange(aWebProgress, aRequest, aState, aIsSimulated) {
     // Don't need to do anything if the data we use to update the UI hasn't
     // changed
     let uri = gBrowser.currentURI;
     let spec = uri.spec;
     if (this._state == aState &&
         this._lastLocation == spec) {
       // Switching to a tab of the same URL doesn't change most security
       // information, but tab specific permissions may be different.
@@ -5012,18 +5011,17 @@ var XULBrowserWindow = {
     // Make sure the "https" part of the URL is striked out or not,
     // depending on the current mixed active content blocking state.
     gURLBar.formatValue();
 
     try {
       uri = Services.uriFixup.createExposableURI(uri);
     } catch (e) {}
     gIdentityHandler.updateIdentity(this._state, uri);
-    ContentBlocking.onSecurityChange(aOldState, this._state, aWebProgress, aIsSimulated,
-                                     aContentBlockingLogJSON);
+    ContentBlocking.onSecurityChange(this._state, aWebProgress, aIsSimulated);
   },
 
   // simulate all change notifications after switching tabs
   onUpdateCurrentBrowser: function XWB_onUpdateCurrentBrowser(aStateFlags, aStatus, aMessage, aTotalProgress) {
     if (FullZoom.updateBackgroundTabs)
       FullZoom.onLocationChange(gBrowser.currentURI, true);
 
     CombinedStopReload.onTabSwitch();
--- a/browser/base/content/tabbrowser.js
+++ b/browser/base/content/tabbrowser.js
@@ -939,23 +939,18 @@ window._gBrowser = {
     this._callProgressListeners(null, "onLocationChange",
                                 [webProgress, null, newBrowser.currentURI, 0, true],
                                 true, false);
 
     let securityUI = newBrowser.securityUI;
     if (securityUI) {
       // Include the true final argument to indicate that this event is
       // simulated (instead of being observed by the webProgressListener).
-      // Note: check state first to make sure the security UI object updates its
-      // state from the docshell correctly.
-      let state = securityUI.state;
-      let oldState = securityUI.oldState;
       this._callProgressListeners(null, "onSecurityChange",
-                                  [webProgress, null, oldState, state,
-                                   securityUI.contentBlockingLogJSON, true],
+                                  [webProgress, null, securityUI.state, true],
                                   true, false);
     }
 
     let listener = this._tabListeners.get(newTab);
     if (listener && listener.mStateFlags) {
       this._callProgressListeners(null, "onUpdateCurrentBrowser",
                                   [listener.mStateFlags, listener.mStatus,
                                    listener.mMessage, listener.mTotalProgress],
@@ -1665,27 +1660,22 @@ window._gBrowser = {
     this._tabListeners.set(tab, listener);
     filter.addProgressListener(listener, Ci.nsIWebProgress.NOTIFY_ALL);
 
     // Restore the progress listener.
     aBrowser.webProgress.addProgressListener(filter, Ci.nsIWebProgress.NOTIFY_ALL);
 
     // Restore the securityUI state.
     let securityUI = aBrowser.securityUI;
-    // Make sure to call the state getter before the oldState getter to give
-    // the securityUI object a chance to sync its state with the docshell
     let state = securityUI ? securityUI.state :
       Ci.nsIWebProgressListener.STATE_IS_INSECURE;
-    let oldState = securityUI ? securityUI.oldState :
-      Ci.nsIWebProgressListener.STATE_IS_INSECURE;
     // Include the true final argument to indicate that this event is
     // simulated (instead of being observed by the webProgressListener).
     this._callProgressListeners(aBrowser, "onSecurityChange",
-                                [aBrowser.webProgress, null, oldState, state,
-                                 securityUI.contentBlockingLogJSON, true],
+                                [aBrowser.webProgress, null, state, true],
                                 true, false);
 
     if (aShouldBeRemote) {
       // Switching the browser to be remote will connect to a new child
       // process so the browser can no longer be considered to be
       // crashed.
       tab.removeAttribute("crashed");
     } else {
@@ -5065,20 +5055,19 @@ class TabProgressListener {
       return;
 
     this._callProgressListeners("onStatusChange",
                                 [aWebProgress, aRequest, aStatus, aMessage]);
 
     this.mMessage = aMessage;
   }
 
-  onSecurityChange(aWebProgress, aRequest, aOldState, aState, aContentBlockingLogJSON) {
+  onSecurityChange(aWebProgress, aRequest, aState) {
     this._callProgressListeners("onSecurityChange",
-                                [aWebProgress, aRequest, aOldState, aState,
-                                 aContentBlockingLogJSON]);
+                                [aWebProgress, aRequest, aState]);
   }
 
   onRefreshAttempted(aWebProgress, aURI, aDelay, aSameURI) {
     return this._callProgressListeners("onRefreshAttempted",
                                        [aWebProgress, aURI, aDelay, aSameURI]);
   }
 }
 TabProgressListener.prototype.QueryInterface = ChromeUtils.generateQI(
--- a/browser/base/content/test/general/browser_alltabslistener.js
+++ b/browser/base/content/test/general/browser_alltabslistener.js
@@ -21,18 +21,17 @@ var gFrontProgressListener = {
     ok(gFrontNotificationsPos < gFrontNotifications.length, "Got an expected notification for the front notifications listener");
     is(state, gFrontNotifications[gFrontNotificationsPos], "Got a notification for the front notifications listener");
     gFrontNotificationsPos++;
   },
 
   onStatusChange(aWebProgress, aRequest, aStatus, aMessage) {
   },
 
-  onSecurityChange(aWebProgress, aRequest, aOldState, aState,
-                   aContentBlockingLogJSON) {
+  onSecurityChange(aWebProgress, aRequest, aState) {
     var state = "onSecurityChange";
     info("FrontProgress: " + state + " 0x" + aState.toString(16));
     ok(gFrontNotificationsPos < gFrontNotifications.length, "Got an expected notification for the front notifications listener");
     is(state, gFrontNotifications[gFrontNotificationsPos], "Got a notification for the front notifications listener");
     gFrontNotificationsPos++;
   },
 };
 
@@ -62,18 +61,17 @@ var gAllProgressListener = {
     gAllNotificationsPos++;
   },
 
   onStatusChange(aBrowser, aWebProgress, aRequest, aStatus, aMessage) {
     var state = "onStatusChange";
     ok(aBrowser == gTestBrowser, state + " notification came from the correct browser");
   },
 
-  onSecurityChange(aBrowser, aWebProgress, aRequest, aOldState, aState,
-                   aContentBlockingLogJSON) {
+  onSecurityChange(aBrowser, aWebProgress, aRequest, aState) {
     var state = "onSecurityChange";
     info("AllProgress: " + state + " 0x" + aState.toString(16));
     ok(aBrowser == gTestBrowser, state + " notification came from the correct browser");
     ok(gAllNotificationsPos < gAllNotifications.length, "Got an expected notification for the all notifications listener");
     is(state, gAllNotifications[gAllNotificationsPos], "Got a notification for the all notifications listener");
     gAllNotificationsPos++;
   },
 };
--- a/browser/components/extensions/parent/ext-tabs.js
+++ b/browser/components/extensions/parent/ext-tabs.js
@@ -1196,18 +1196,17 @@ this.tabs = class extends ExtensionAPI {
                 }
                 if (pageSettings.footerRight !== null) {
                   printSettings.footerStrRight = pageSettings.footerRight;
                 }
 
                 let printProgressListener = {
                   onLocationChange(webProgress, request, location, flags) { },
                   onProgressChange(webProgress, request, curSelfProgress, maxSelfProgress, curTotalProgress, maxTotalProgress) { },
-                  onSecurityChange(webProgress, request, oldState, state,
-                                   contentBlockingLogJSON) { },
+                  onSecurityChange(webProgress, request, state) { },
                   onStateChange(webProgress, request, flags, status) {
                     if ((flags & Ci.nsIWebProgressListener.STATE_STOP) && (flags & Ci.nsIWebProgressListener.STATE_IS_DOCUMENT)) {
                       resolve(retval == 0 ? "saved" : "replaced");
                     }
                   },
                   onStatusChange: function(webProgress, request, status, message) {
                     if (status != 0) {
                       resolve(retval == 0 ? "not_saved" : "not_replaced");
--- a/browser/components/shell/nsMacShellService.cpp
+++ b/browser/components/shell/nsMacShellService.cpp
@@ -186,19 +186,17 @@ nsMacShellService::OnStatusChange(nsIWeb
                                   const char16_t* aMessage)
 {
   return NS_OK;
 }
 
 NS_IMETHODIMP
 nsMacShellService::OnSecurityChange(nsIWebProgress* aWebProgress,
                                     nsIRequest* aRequest,
-                                    uint32_t aOldState,
-                                    uint32_t aState,
-                                    const nsAString& aContentBlockingLogJSON)
+                                    uint32_t aState)
 {
   return NS_OK;
 }
 
 NS_IMETHODIMP
 nsMacShellService::OnStateChange(nsIWebProgress* aWebProgress,
                                  nsIRequest* aRequest,
                                  uint32_t aStateFlags,
--- a/docshell/base/nsDocShell.cpp
+++ b/docshell/base/nsDocShell.cpp
@@ -7002,19 +7002,17 @@ nsDocShell::OnStatusChange(nsIWebProgres
                            nsresult aStatus, const char16_t* aMessage)
 {
   MOZ_ASSERT_UNREACHABLE("notification excluded in AddProgressListener(...)");
   return NS_OK;
 }
 
 NS_IMETHODIMP
 nsDocShell::OnSecurityChange(nsIWebProgress* aWebProgress,
-                             nsIRequest* aRequest, uint32_t aOldState,
-                             uint32_t aState,
-                             const nsAString& aContentBlockingLogJSON)
+                             nsIRequest* aRequest, uint32_t aState)
 {
   MOZ_ASSERT_UNREACHABLE("notification excluded in AddProgressListener(...)");
   return NS_OK;
 }
 
 nsresult
 nsDocShell::EndPageLoad(nsIWebProgress* aProgress,
                         nsIChannel* aChannel, nsresult aStatus)
--- a/docshell/base/nsDocShellTreeOwner.cpp
+++ b/docshell/base/nsDocShellTreeOwner.cpp
@@ -762,19 +762,17 @@ nsDocShellTreeOwner::OnStatusChange(nsIW
                                     const char16_t* aMessage)
 {
   return NS_OK;
 }
 
 NS_IMETHODIMP
 nsDocShellTreeOwner::OnSecurityChange(nsIWebProgress* aWebProgress,
                                       nsIRequest* aRequest,
-                                      uint32_t aOldState,
-                                      uint32_t aState,
-                                      const nsAString& aContentBlockingLogJSON)
+                                      uint32_t aState)
 {
   return NS_OK;
 }
 
 //*****************************************************************************
 // nsDocShellTreeOwner: Accessors
 //*****************************************************************************
 
deleted file mode 100644
--- a/dom/base/ContentBlockingLog.h
+++ /dev/null
@@ -1,155 +0,0 @@
-/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/* vim: set ts=8 sts=2 et sw=2 tw=80: */
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-
-#ifndef mozilla_dom_ContentBlockingLog_h
-#define mozilla_dom_ContentBlockingLog_h
-
-#include "mozilla/JSONWriter.h"
-#include "mozilla/StaticPrefs.h"
-#include "mozilla/UniquePtr.h"
-#include "nsClassHashtable.h"
-#include "nsHashKeys.h"
-#include "nsReadableUtils.h"
-#include "nsTArray.h"
-#include "nsWindowSizes.h"
-
-namespace mozilla {
-namespace dom {
-
-class ContentBlockingLog final
-{
-  struct LogEntry {
-    uint32_t mType;
-    uint32_t mRepeatCount;
-    bool mBlocked;
-  };
-
-  // Each element is a tuple of (type, blocked, repeatCount). The type values
-  // come from the blocking types defined in nsIWebProgressListener.
-  typedef nsTArray<LogEntry> OriginLog;
-  typedef nsClassHashtable<nsStringHashKey, OriginLog> OriginLogHashTable;
-
-  struct StringWriteFunc : public JSONWriteFunc
-  {
-    nsAString& mBuffer; // The lifetime of the struct must be bound to the buffer
-    explicit StringWriteFunc(nsAString& aBuffer)
-      : mBuffer(aBuffer)
-    {}
-
-    void Write(const char* aStr) override
-    {
-      mBuffer.Append(NS_ConvertUTF8toUTF16(aStr));
-    }
-  };
-
-public:
-  ContentBlockingLog() = default;
-  ~ContentBlockingLog() = default;
-
-  void RecordLog(const nsAString& aOrigin, uint32_t aType, bool aBlocked)
-  {
-    if (aOrigin.IsVoid()) {
-      return;
-    }
-    auto entry = mLog.LookupForAdd(aOrigin);
-    if (entry) {
-      auto& log = entry.Data();
-      if (!log->IsEmpty()) {
-        auto& last = log->LastElement();
-        if (last.mType == aType &&
-            last.mBlocked == aBlocked) {
-          ++last.mRepeatCount;
-          // Don't record recorded events.  This helps compress our log.
-          return;
-        }
-      }
-      if (log->Length() ==
-            std::max(1u, StaticPrefs::browser_contentblocking_originlog_length())) {
-        // Cap the size at the maximum length adjustable by the pref
-        log->RemoveElementAt(0);
-      }
-      log->AppendElement(LogEntry{aType, 1u, aBlocked});
-    } else {
-      entry.OrInsert([=] {
-        auto log(MakeUnique<OriginLog>());
-        log->AppendElement(LogEntry{aType, 1u, aBlocked});
-        return log.release();
-      });
-    }
-  }
-
-  nsAutoString Stringify()
-  {
-    nsAutoString buffer;
-
-    JSONWriter w(MakeUnique<StringWriteFunc>(buffer));
-    w.Start();
-
-    for (auto iter = mLog.Iter(); !iter.Done(); iter.Next()) {
-      if (!iter.UserData()) {
-        w.StartArrayProperty(NS_ConvertUTF16toUTF8(iter.Key()).get(), w.SingleLineStyle);
-        w.EndArray();
-        continue;
-      }
-
-      w.StartArrayProperty(NS_ConvertUTF16toUTF8(iter.Key()).get(), w.SingleLineStyle);
-      for (auto& item: *iter.UserData()) {
-        w.StartArrayElement(w.SingleLineStyle);
-        {
-          w.IntElement(item.mType);
-          w.BoolElement(item.mBlocked);
-          w.IntElement(item.mRepeatCount);
-        }
-        w.EndArray();
-      }
-      w.EndArray();
-    }
-
-    w.End();
-
-    return buffer;
-  }
-
-  bool HasBlockedAnyOfType(uint32_t aType)
-  {
-    for (auto iter = mLog.Iter(); !iter.Done(); iter.Next()) {
-      if (!iter.UserData()) {
-        continue;
-      }
-
-      for (auto& item: *iter.UserData()) {
-        if ((item.mType & aType) != 0) {
-          return true;
-        }
-      }
-    }
-    return false;
-  }
-
-  void AddSizeOfExcludingThis(nsWindowSizes& aSizes) const
-  {
-    aSizes.mDOMOtherSize += mLog.ShallowSizeOfExcludingThis(aSizes.mState.mMallocSizeOf);
-
-    // Now add the sizes of each origin log queue.
-    // The const_cast is needed because the nsTHashtable::Iterator interface is
-    // not const-safe.  :-(
-    for (auto iter = const_cast<OriginLogHashTable&>(mLog).Iter();
-         !iter.Done(); iter.Next()) {
-      if (iter.UserData()) {
-        aSizes.mDOMOtherSize +=
-          iter.UserData()->ShallowSizeOfIncludingThis(aSizes.mState.mMallocSizeOf);
-      }
-    }
-  }
-
-private:
-  OriginLogHashTable mLog;
-};
-
-} // namespace dom
-} // namespace mozilla
-
-#endif
--- a/dom/base/moz.build
+++ b/dom/base/moz.build
@@ -148,17 +148,16 @@ EXPORTS.mozilla.dom += [
     'CharacterData.h',
     'ChildIterator.h',
     'ChildProcessMessageManager.h',
     'ChromeMessageBroadcaster.h',
     'ChromeMessageSender.h',
     'ChromeNodeList.h',
     'ChromeUtils.h',
     'Comment.h',
-    'ContentBlockingLog.h',
     'ContentFrameMessageManager.h',
     'ContentProcessMessageManager.h',
     'CustomElementRegistry.h',
     'DirectionalityUtils.h',
     'DispatcherTrait.h',
     'DocGroup.h',
     'DocumentFragment.h',
     'DocumentOrShadowRoot.h',
--- a/dom/base/nsDocument.cpp
+++ b/dom/base/nsDocument.cpp
@@ -1398,16 +1398,22 @@ nsIDocument::nsIDocument()
     mHasMixedActiveContentLoaded(false),
     mHasMixedActiveContentBlocked(false),
     mHasMixedDisplayContentLoaded(false),
     mHasMixedDisplayContentBlocked(false),
     mHasMixedContentObjectSubrequest(false),
     mHasCSP(false),
     mHasUnsafeEvalCSP(false),
     mHasUnsafeInlineCSP(false),
+    mHasTrackingContentBlocked(false),
+    mHasSlowTrackingContentBlocked(false),
+    mHasAllCookiesBlocked(false),
+    mHasTrackingCookiesBlocked(false),
+    mHasForeignCookiesBlocked(false),
+    mHasCookiesBlockedByPermission(false),
     mHasTrackingContentLoaded(false),
     mBFCacheDisallowed(false),
     mHasHadDefaultView(false),
     mStyleSheetChangeEventsEnabled(false),
     mIsSrcdocDocument(false),
     mDidDocumentOpen(false),
     mHasDisplayDocument(false),
     mFontFaceSetDirty(true),
@@ -11778,18 +11784,16 @@ nsIDocument::DocAddSizeOfExcludingThis(n
   aSizes.mDOMMediaQueryLists +=
     mDOMMediaQueryLists.sizeOfExcludingThis(aSizes.mState.mMallocSizeOf);
 
   for (const MediaQueryList* mql : mDOMMediaQueryLists) {
     aSizes.mDOMMediaQueryLists +=
       mql->SizeOfExcludingThis(aSizes.mState.mMallocSizeOf);
   }
 
-  mContentBlockingLog.AddSizeOfExcludingThis(aSizes);
-
   // Measurement of the following members may be added later if DMD finds it
   // is worthwhile:
   // - many!
 }
 
 void
 nsIDocument::DocAddSizeOfIncludingThis(nsWindowSizes& aWindowSizes) const
 {
--- a/dom/base/nsGlobalWindowOuter.cpp
+++ b/dom/base/nsGlobalWindowOuter.cpp
@@ -5276,95 +5276,63 @@ nsGlobalWindowOuter::FirePopupBlockedEve
 
   event->SetTrusted(true);
 
   aDoc->DispatchEvent(*event);
 }
 
 void
 nsGlobalWindowOuter::NotifyContentBlockingState(unsigned aState,
-                                                nsIChannel* aChannel,
-                                                bool aBlocked,
-                                                nsIURI* aURIHint)
+                                                nsIChannel* aChannel)
 {
   nsCOMPtr<nsIDocShell> docShell = GetDocShell();
   if (!docShell) {
     return;
   }
   nsCOMPtr<nsIDocument> doc = docShell->GetDocument();
   NS_ENSURE_TRUE_VOID(doc);
 
   // This event might come after the user has navigated to another page.
   // To prevent showing the TrackingProtection UI on the wrong page, we need to
   // check that the loading URI for the channel is the same as the URI currently
   // loaded in the document.
-  if (!SameLoadingURI(doc, aChannel) &&
-      aState == nsIWebProgressListener::STATE_BLOCKED_TRACKING_CONTENT) {
+  if (!SameLoadingURI(doc, aChannel)) {
     return;
   }
 
   // Notify nsIWebProgressListeners of this security event.
   // Can be used to change the UI state.
   nsresult rv = NS_OK;
   nsCOMPtr<nsISecurityEventSink> eventSink = do_QueryInterface(docShell, &rv);
   NS_ENSURE_SUCCESS_VOID(rv);
   uint32_t state = 0;
   nsCOMPtr<nsISecureBrowserUI> securityUI;
   docShell->GetSecurityUI(getter_AddRefs(securityUI));
   if (!securityUI) {
     return;
   }
   securityUI->GetState(&state);
-  nsAutoString origin;
-  origin.SetIsVoid(true);
-  if (aURIHint) {
-    nsContentUtils::GetUTFOrigin(aURIHint, origin);
-  }
-  bool unblocked = false;
   if (aState == nsIWebProgressListener::STATE_BLOCKED_TRACKING_CONTENT) {
-    doc->SetHasTrackingContentBlocked(aBlocked, origin);
-    if (!aBlocked) {
-      unblocked = !doc->GetHasTrackingContentBlocked();
-    }
+    doc->SetHasTrackingContentBlocked(true);
   } else if (aState == nsIWebProgressListener::STATE_BLOCKED_SLOW_TRACKING_CONTENT) {
-    doc->SetHasSlowTrackingContentBlocked(aBlocked, origin);
-    if (!aBlocked) {
-      unblocked = !doc->GetHasSlowTrackingContentBlocked();
-    }
+    doc->SetHasSlowTrackingContentBlocked(true);
   } else if (aState == nsIWebProgressListener::STATE_COOKIES_BLOCKED_BY_PERMISSION) {
-    doc->SetHasCookiesBlockedByPermission(aBlocked, origin);
-    if (!aBlocked) {
-      unblocked = !doc->GetHasCookiesBlockedByPermission();
-    }
+    doc->SetHasCookiesBlockedByPermission(true);
   } else if (aState == nsIWebProgressListener::STATE_COOKIES_BLOCKED_TRACKER) {
-    doc->SetHasTrackingCookiesBlocked(aBlocked, origin);
-    if (!aBlocked) {
-      unblocked = !doc->GetHasTrackingCookiesBlocked();
-    }
+    doc->SetHasTrackingCookiesBlocked(true);
   } else if (aState == nsIWebProgressListener::STATE_COOKIES_BLOCKED_ALL) {
-    doc->SetHasAllCookiesBlocked(aBlocked, origin);
-    if (!aBlocked) {
-      unblocked = !doc->GetHasAllCookiesBlocked();
-    }
+    doc->SetHasAllCookiesBlocked(true);
   } else if (aState == nsIWebProgressListener::STATE_COOKIES_BLOCKED_FOREIGN) {
-    doc->SetHasForeignCookiesBlocked(aBlocked, origin);
-    if (!aBlocked) {
-      unblocked = !doc->GetHasForeignCookiesBlocked();
-    }
+    doc->SetHasForeignCookiesBlocked(true);
   } else {
     // Ignore nsIWebProgressListener::STATE_BLOCKED_UNSAFE_CONTENT;
   }
-  const uint32_t oldState = state;
-  if (aBlocked) {
-    state |= aState;
-  } else if (unblocked) {
-    state &= ~aState;
-  }
-
-  eventSink->OnSecurityChange(aChannel, oldState, state, doc->GetContentBlockingLog());
+  state |= aState;
+
+  eventSink->OnSecurityChange(aChannel, state);
 }
 
 //static
 bool
 nsGlobalWindowOuter::SameLoadingURI(nsIDocument *aDoc, nsIChannel *aChannel)
 {
   nsCOMPtr<nsIURI> docURI = aDoc->GetDocumentURI();
   nsCOMPtr<nsILoadInfo> channelLoadInfo = aChannel->GetLoadInfo();
--- a/dom/base/nsGlobalWindowOuter.h
+++ b/dom/base/nsGlobalWindowOuter.h
@@ -479,19 +479,17 @@ public:
   virtual void
   FirePopupBlockedEvent(nsIDocument* aDoc,
                         nsIURI* aPopupURI,
                         const nsAString& aPopupWindowName,
                         const nsAString& aPopupWindowFeatures) override;
 
   virtual void
   NotifyContentBlockingState(unsigned aState,
-                             nsIChannel* aChannel,
-                             bool aBlocked,
-                             nsIURI* aURIHint) override;
+                             nsIChannel* aChannel) override;
 
   virtual uint32_t GetSerial() override {
     return mSerial;
   }
 
   void AddSizeOfIncludingThis(nsWindowSizes& aWindowSizes) const;
 
   void AllowScriptsToClose()
--- a/dom/base/nsIDocument.h
+++ b/dom/base/nsIDocument.h
@@ -2,17 +2,16 @@
 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 #ifndef nsIDocument_h___
 #define nsIDocument_h___
 
 #include "mozilla/FlushType.h"           // for enum
-#include "mozilla/Pair.h"                // for Pair
 #include "nsAutoPtr.h"                   // for member
 #include "nsCOMArray.h"                  // for member
 #include "nsCompatibility.h"             // for member
 #include "nsCOMPtr.h"                    // for member
 #include "nsGkAtoms.h"                   // for static class members
 #include "nsIApplicationCache.h"
 #include "nsIApplicationCacheContainer.h"
 #include "nsIContentViewer.h"
@@ -25,32 +24,30 @@
 #include "nsIPresShell.h"
 #include "nsIChannelEventSink.h"
 #include "nsIProgressEventSink.h"
 #include "nsISecurityEventSink.h"
 #include "nsIScriptGlobalObject.h"       // for member (in nsCOMPtr)
 #include "nsIServiceManager.h"
 #include "nsIURI.h"                      // for use in inline functions
 #include "nsIUUIDGenerator.h"
-#include "nsIWebProgressListener.h"      // for nsIWebProgressListener
 #include "nsPIDOMWindow.h"               // for use in inline functions
 #include "nsPropertyTable.h"             // for member
 #include "nsStringFwd.h"
 #include "nsTHashtable.h"                // for member
 #include "nsURIHashKey.h"
 #include "mozilla/net/ReferrerPolicy.h"  // for member
 #include "nsWeakReference.h"
 #include "mozilla/UseCounter.h"
 #include "mozilla/WeakPtr.h"
 #include "Units.h"
 #include "nsContentListDeclarations.h"
 #include "nsExpirationTracker.h"
 #include "nsClassHashtable.h"
 #include "mozilla/CORSMode.h"
-#include "mozilla/dom/ContentBlockingLog.h"
 #include "mozilla/dom/DispatcherTrait.h"
 #include "mozilla/dom/DocumentOrShadowRoot.h"
 #include "mozilla/EnumSet.h"
 #include "mozilla/LinkedList.h"
 #include "mozilla/NotNull.h"
 #include "mozilla/SegmentedVector.h"
 #include "mozilla/ServoBindingTypes.h"
 #include "mozilla/StyleSheet.h"
@@ -975,141 +972,109 @@ public:
    * Set unsafe-eval CSP flag for this document.
    */
   void SetHasUnsafeEvalCSP(bool aHasUnsafeEvalCSP)
   {
     mHasUnsafeEvalCSP = aHasUnsafeEvalCSP;
   }
 
   /**
-   * Get the content blocking log.
-   */
-  mozilla::dom::ContentBlockingLog* GetContentBlockingLog()
-  {
-    return &mContentBlockingLog;
-  }
-
-  /**
    * Get tracking content blocked flag for this document.
    */
   bool GetHasTrackingContentBlocked()
   {
-    return mContentBlockingLog.HasBlockedAnyOfType(
-        nsIWebProgressListener::STATE_BLOCKED_TRACKING_CONTENT);
+    return mHasTrackingContentBlocked;
   }
 
   /**
    * Get slow tracking content blocked flag for this document.
    */
   bool GetHasSlowTrackingContentBlocked()
   {
-    return mContentBlockingLog.HasBlockedAnyOfType(
-        nsIWebProgressListener::STATE_BLOCKED_SLOW_TRACKING_CONTENT);
+    return mHasSlowTrackingContentBlocked;
   }
 
   /**
    * Get all cookies blocked flag for this document.
    */
   bool GetHasAllCookiesBlocked()
   {
-    return mContentBlockingLog.HasBlockedAnyOfType(
-        nsIWebProgressListener::STATE_COOKIES_BLOCKED_ALL);
+    return mHasAllCookiesBlocked;
   }
 
   /**
    * Get tracking cookies blocked flag for this document.
    */
   bool GetHasTrackingCookiesBlocked()
   {
-    return mContentBlockingLog.HasBlockedAnyOfType(
-        nsIWebProgressListener::STATE_COOKIES_BLOCKED_TRACKER);
+    return mHasTrackingCookiesBlocked;
   }
 
   /**
    * Get third-party cookies blocked flag for this document.
    */
   bool GetHasForeignCookiesBlocked()
   {
-    return mContentBlockingLog.HasBlockedAnyOfType(
-        nsIWebProgressListener::STATE_COOKIES_BLOCKED_FOREIGN);
+    return mHasForeignCookiesBlocked;
   }
 
   /**
    * Get cookies blocked by site permission flag for this document.
    */
   bool GetHasCookiesBlockedByPermission()
   {
-    return mContentBlockingLog.HasBlockedAnyOfType(
-        nsIWebProgressListener::STATE_COOKIES_BLOCKED_BY_PERMISSION);
+    return mHasCookiesBlockedByPermission;
   }
 
   /**
    * Set the tracking content blocked flag for this document.
    */
-  void SetHasTrackingContentBlocked(bool aHasTrackingContentBlocked,
-                                    const nsAString& aOriginBlocked)
-  {
-    RecordContentBlockingLog(aOriginBlocked,
-                             nsIWebProgressListener::STATE_BLOCKED_TRACKING_CONTENT,
-                             aHasTrackingContentBlocked);
+  void SetHasTrackingContentBlocked(bool aHasTrackingContentBlocked)
+  {
+    mHasTrackingContentBlocked = aHasTrackingContentBlocked;
   }
 
   /**
    * Set the slow tracking content blocked flag for this document.
    */
-  void SetHasSlowTrackingContentBlocked(bool aHasSlowTrackingContentBlocked,
-                                        const nsAString& aOriginBlocked)
-  {
-    RecordContentBlockingLog(aOriginBlocked,
-                             nsIWebProgressListener::STATE_BLOCKED_SLOW_TRACKING_CONTENT,
-                             aHasSlowTrackingContentBlocked);
+  void SetHasSlowTrackingContentBlocked(bool aHasSlowTrackingContentBlocked)
+  {
+    mHasSlowTrackingContentBlocked = aHasSlowTrackingContentBlocked;
   }
 
   /**
    * Set the all cookies blocked flag for this document.
    */
-  void SetHasAllCookiesBlocked(bool aHasAllCookiesBlocked,
-                               const nsAString& aOriginBlocked)
-  {
-    RecordContentBlockingLog(aOriginBlocked,
-                             nsIWebProgressListener::STATE_COOKIES_BLOCKED_ALL,
-                             aHasAllCookiesBlocked);
+  void SetHasAllCookiesBlocked(bool aHasAllCookiesBlocked)
+  {
+    mHasAllCookiesBlocked = aHasAllCookiesBlocked;
   }
 
   /**
    * Set the tracking cookies blocked flag for this document.
    */
-  void SetHasTrackingCookiesBlocked(bool aHasTrackingCookiesBlocked,
-                                    const nsAString& aOriginBlocked)
-  {
-    RecordContentBlockingLog(aOriginBlocked,
-                             nsIWebProgressListener::STATE_COOKIES_BLOCKED_TRACKER,
-                             aHasTrackingCookiesBlocked);
+  void SetHasTrackingCookiesBlocked(bool aHasTrackingCookiesBlocked)
+  {
+    mHasTrackingCookiesBlocked = aHasTrackingCookiesBlocked;
   }
 
   /**
    * Set the third-party cookies blocked flag for this document.
    */
-  void SetHasForeignCookiesBlocked(bool aHasForeignCookiesBlocked,
-                                   const nsAString& aOriginBlocked)
-  {
-    RecordContentBlockingLog(aOriginBlocked,
-                             nsIWebProgressListener::STATE_COOKIES_BLOCKED_FOREIGN,
-                             aHasForeignCookiesBlocked);
+  void SetHasForeignCookiesBlocked(bool aHasForeignCookiesBlocked)
+  {
+    mHasForeignCookiesBlocked = aHasForeignCookiesBlocked;
   }
 
   /**
    * Set the cookies blocked by site permission flag for this document.
    */
-  void SetHasCookiesBlockedByPermission(bool aHasCookiesBlockedByPermission,
-                                        const nsAString& aOriginBlocked)
-  {
-    RecordContentBlockingLog(aOriginBlocked,
-                             nsIWebProgressListener::STATE_COOKIES_BLOCKED_BY_PERMISSION,
-                             aHasCookiesBlockedByPermission);
+  void SetHasCookiesBlockedByPermission(bool aHasCookiesBlockedByPermission)
+  {
+    mHasCookiesBlockedByPermission = aHasCookiesBlockedByPermission;
   }
 
   /**
    * Get tracking content loaded flag for this document.
    */
   bool GetHasTrackingContentLoaded()
   {
     return mHasTrackingContentLoaded;
@@ -3880,22 +3845,16 @@ protected:
   void NotifyStyleSheetApplicableStateChanged();
   // Just like EnableStyleSheetsForSet, but doesn't check whether
   // aSheetSet is null and allows the caller to control whether to set
   // aSheetSet as the preferred set in the CSSLoader.
   void EnableStyleSheetsForSetInternal(const nsAString& aSheetSet,
                                        bool aUpdateCSSLoader);
 
 private:
-  void RecordContentBlockingLog(const nsAString& aOrigin,
-                                uint32_t aType, bool aBlocked)
-  {
-    mContentBlockingLog.RecordLog(aOrigin, aType, aBlocked);
-  }
-
   mutable std::bitset<eDeprecatedOperationCount> mDeprecationWarnedAbout;
   mutable std::bitset<eDocumentWarningCount> mDocWarningWarnedAbout;
 
   // Lazy-initialization to have mDocGroup initialized in prior to the
   // SelectorCaches.
   mozilla::UniquePtr<SelectorCache> mSelectorCache;
 
 protected:
@@ -4185,16 +4144,34 @@ protected:
   bool mHasCSP : 1;
 
   // True if a document load has a CSP with unsafe-eval attached.
   bool mHasUnsafeEvalCSP : 1;
 
   // True if a document load has a CSP with unsafe-inline attached.
   bool mHasUnsafeInlineCSP : 1;
 
+  // True if a document has blocked Tracking Content
+  bool mHasTrackingContentBlocked : 1;
+
+  // True if a document has blocked Slow Tracking Content
+  bool mHasSlowTrackingContentBlocked : 1;
+
+  // True if a document has blocked All Cookies
+  bool mHasAllCookiesBlocked : 1;
+
+  // True if a document has blocked Tracking Cookies
+  bool mHasTrackingCookiesBlocked : 1;
+
+  // True if a document has blocked Foreign Cookies
+  bool mHasForeignCookiesBlocked : 1;
+
+  // True if a document has blocked Cookies By Site Permission
+  bool mHasCookiesBlockedByPermission : 1;
+
   // True if a document has loaded Tracking Content
   bool mHasTrackingContentLoaded : 1;
 
   // True if DisallowBFCaching has been called on this document.
   bool mBFCacheDisallowed : 1;
 
   bool mHasHadDefaultView : 1;
 
@@ -4537,21 +4514,16 @@ protected:
 
   RefPtr<mozilla::dom::DocGroup> mDocGroup;
 
   // The set of all the tracking script URLs.  URLs are added to this set by
   // calling NoteScriptTrackingStatus().  Currently we assume that a URL not
   // existing in the set means the corresponding script isn't a tracking script.
   nsTHashtable<nsCStringHashKey> mTrackingScripts;
 
-  // The log of all content blocking actions taken on this document.  This is only
-  // stored on top-level documents and includes the activity log for all of the
-  // nested subdocuments as well.
-  mozilla::dom::ContentBlockingLog mContentBlockingLog;
-
   // List of ancestor principals.  This is set at the point a document
   // is connected to a docshell and not mutated thereafter.
   nsTArray<nsCOMPtr<nsIPrincipal>> mAncestorPrincipals;
   // List of ancestor outerWindowIDs that correspond to the ancestor principals.
   nsTArray<uint64_t> mAncestorOuterWindowIDs;
 
   // Pointer to our parser if we're currently in the process of being
   // parsed into.
--- a/dom/base/nsPIDOMWindow.h
+++ b/dom/base/nsPIDOMWindow.h
@@ -1089,19 +1089,17 @@ public:
   virtual void
   FirePopupBlockedEvent(nsIDocument* aDoc,
                         nsIURI* aPopupURI,
                         const nsAString& aPopupWindowName,
                         const nsAString& aPopupWindowFeatures) = 0;
 
   virtual void
   NotifyContentBlockingState(unsigned aState,
-                             nsIChannel* aChannel,
-                             bool aBlocked = true,
-                             nsIURI* aURIHint = nullptr) = 0;
+                             nsIChannel* aChannel) = 0;
 
   // WebIDL-ish APIs
   void MarkUncollectableForCCGeneration(uint32_t aGeneration)
   {
     mMarkedCCGeneration = aGeneration;
   }
 
   uint32_t GetMarkedCCGeneration()
--- a/dom/browser-element/BrowserElementChildPreload.js
+++ b/dom/browser-element/BrowserElementChildPreload.js
@@ -1534,18 +1534,17 @@ BrowserElementChild.prototype = {
             } catch (e) {}
 
             sendAsyncMsg('error', { type: 'other' });
             return;
         }
       }
     },
 
-    onSecurityChange: function(webProgress, request, oldState, state,
-                               contentBlockingLogJSON) {
+    onSecurityChange: function(webProgress, request, state) {
       if (webProgress != docShell) {
         return;
       }
 
       var securityStateDesc;
       if (state & Ci.nsIWebProgressListener.STATE_IS_SECURE) {
         securityStateDesc = 'secure';
       }
--- a/dom/clients/manager/ClientNavigateOpChild.cpp
+++ b/dom/clients/manager/ClientNavigateOpChild.cpp
@@ -123,18 +123,17 @@ public:
                  nsresult aStatus, const char16_t* aMessage) override
   {
     MOZ_CRASH("Unexpected notification.");
     return NS_OK;
   }
 
   NS_IMETHOD
   OnSecurityChange(nsIWebProgress* aWebProgress, nsIRequest* aRequest,
-                   uint32_t aOldState, uint32_t aState,
-                   const nsAString& aContentBlockingLogJSON) override
+                   uint32_t aState) override
   {
     MOZ_CRASH("Unexpected notification.");
     return NS_OK;
   }
 
   NS_DECL_ISUPPORTS
 };
 
--- a/dom/clients/manager/ClientOpenWindowUtils.cpp
+++ b/dom/clients/manager/ClientOpenWindowUtils.cpp
@@ -128,19 +128,17 @@ public:
   {
     MOZ_ASSERT(false, "Unexpected notification.");
     return NS_OK;
   }
 
   NS_IMETHOD
   OnSecurityChange(nsIWebProgress* aWebProgress,
                    nsIRequest* aRequest,
-                   uint32_t aOldState,
-                   uint32_t aState,
-                   const nsAString& aContentBlockingLogJSON) override
+                   uint32_t aState) override
   {
     MOZ_ASSERT(false, "Unexpected notification.");
     return NS_OK;
   }
 
 private:
   ~WebProgressListener()
   {
--- a/dom/html/HTMLFormElement.cpp
+++ b/dom/html/HTMLFormElement.cpp
@@ -2126,19 +2126,17 @@ HTMLFormElement::OnStatusChange(nsIWebPr
 {
   MOZ_ASSERT_UNREACHABLE("notification excluded in AddProgressListener(...)");
   return NS_OK;
 }
 
 NS_IMETHODIMP
 HTMLFormElement::OnSecurityChange(nsIWebProgress* aWebProgress,
                                   nsIRequest* aRequest,
-                                  uint32_t aOldState,
-                                  uint32_t aState,
-                                  const nsAString& aContentBlockingLogJSON)
+                                  uint32_t state)
 {
   MOZ_ASSERT_UNREACHABLE("notification excluded in AddProgressListener(...)");
   return NS_OK;
 }
 
 NS_IMETHODIMP_(int32_t)
 HTMLFormElement::IndexOfControl(nsIFormControl* aControl)
 {
--- a/dom/html/nsHTMLDNSPrefetch.cpp
+++ b/dom/html/nsHTMLDNSPrefetch.cpp
@@ -572,19 +572,17 @@ nsHTMLDNSPrefetch::nsDeferrals::OnStatus
                                                const char16_t* aMessage)
 {
   return NS_OK;
 }
 
 NS_IMETHODIMP
 nsHTMLDNSPrefetch::nsDeferrals::OnSecurityChange(nsIWebProgress *aWebProgress,
                                                  nsIRequest *aRequest,
-                                                 uint32_t aOldState,
-                                                 uint32_t aState,
-                                                 const nsAString& aContentBlockingLogJSON)
+                                                 uint32_t state)
 {
   return NS_OK;
 }
 
 //////////// nsIObserver method
 
 NS_IMETHODIMP
 nsHTMLDNSPrefetch::nsDeferrals::Observe(nsISupports *subject,
--- a/dom/presentation/PresentationCallbacks.cpp
+++ b/dom/presentation/PresentationCallbacks.cpp
@@ -268,15 +268,13 @@ PresentationResponderLoadingCallback::On
 {
   // Do nothing.
   return NS_OK;
 }
 
 NS_IMETHODIMP
 PresentationResponderLoadingCallback::OnSecurityChange(nsIWebProgress* aWebProgress,
                                                        nsIRequest* aRequest,
-                                                       uint32_t aOldState,
-                                                       uint32_t aState,
-                                                       const nsAString& aContentBlockingLogJSON)
+                                                       uint32_t state)
 {
   // Do nothing.
   return NS_OK;
 }
--- a/dom/security/nsMixedContentBlocker.cpp
+++ b/dom/security/nsMixedContentBlocker.cpp
@@ -103,17 +103,16 @@ public:
     }
     nsCOMPtr<nsIDocShellTreeItem> sameTypeRoot;
     docShell->GetSameTypeRootTreeItem(getter_AddRefs(sameTypeRoot));
     NS_ASSERTION(sameTypeRoot, "No document shell root tree item from document shell tree item!");
 
     // now get the document from sameTypeRoot
     nsCOMPtr<nsIDocument> rootDoc = sameTypeRoot->GetDocument();
     NS_ASSERTION(rootDoc, "No root document from document shell root tree item.");
-    ContentBlockingLog* contentBlockingLog = rootDoc->GetContentBlockingLog();
 
     // Get eventSink and the current security state from the docShell
     nsCOMPtr<nsISecurityEventSink> eventSink = do_QueryInterface(docShell);
     NS_ASSERTION(eventSink, "No eventSink from docShell.");
     nsCOMPtr<nsIDocShell> rootShell = do_GetInterface(sameTypeRoot);
     NS_ASSERTION(rootShell, "No root docshell from document shell root tree item.");
     uint32_t state = nsIWebProgressListener::STATE_IS_BROKEN;
     nsCOMPtr<nsISecureBrowserUI> securityUI;
@@ -143,25 +142,22 @@ public:
           // set state security flag to broken, since there is mixed content
           state |= nsIWebProgressListener::STATE_IS_BROKEN;
 
           // If mixed display content is loaded, make sure to include that in the state.
           if (rootDoc->GetHasMixedDisplayContentLoaded()) {
             state |= nsIWebProgressListener::STATE_LOADED_MIXED_DISPLAY_CONTENT;
           }
 
-          eventSink->OnSecurityChange(mContext, state,
-                                      (state | nsIWebProgressListener::STATE_LOADED_MIXED_ACTIVE_CONTENT),
-                                      contentBlockingLog);
+          eventSink->OnSecurityChange(mContext,
+                                      (state | nsIWebProgressListener::STATE_LOADED_MIXED_ACTIVE_CONTENT));
         } else {
           // root not secure, mixed active content loaded in an https subframe
           if (NS_SUCCEEDED(stateRV)) {
-            eventSink->OnSecurityChange(mContext, state,
-                                        (state | nsIWebProgressListener::STATE_LOADED_MIXED_ACTIVE_CONTENT),
-                                        contentBlockingLog);
+            eventSink->OnSecurityChange(mContext, (state | nsIWebProgressListener::STATE_LOADED_MIXED_ACTIVE_CONTENT));
           }
         }
       }
 
     } else if (mType == eMixedDisplay) {
       // See if the pref will change here. If it will, only then do we need to call OnSecurityChange() to update the UI.
       if (rootDoc->GetHasMixedDisplayContentLoaded()) {
         return NS_OK;
@@ -178,25 +174,22 @@ public:
           // set state security flag to broken, since there is mixed content
           state |= nsIWebProgressListener::STATE_IS_BROKEN;
 
           // If mixed active content is loaded, make sure to include that in the state.
           if (rootDoc->GetHasMixedActiveContentLoaded()) {
             state |= nsIWebProgressListener::STATE_LOADED_MIXED_ACTIVE_CONTENT;
           }
 
-          eventSink->OnSecurityChange(mContext, state,
-                                      (state | nsIWebProgressListener::STATE_LOADED_MIXED_DISPLAY_CONTENT),
-                                      contentBlockingLog);
+          eventSink->OnSecurityChange(mContext,
+                                      (state | nsIWebProgressListener::STATE_LOADED_MIXED_DISPLAY_CONTENT));
         } else {
           // root not secure, mixed display content loaded in an https subframe
           if (NS_SUCCEEDED(stateRV)) {
-            eventSink->OnSecurityChange(mContext, state,
-                                        (state | nsIWebProgressListener::STATE_LOADED_MIXED_DISPLAY_CONTENT),
-                                        contentBlockingLog);
+            eventSink->OnSecurityChange(mContext, (state | nsIWebProgressListener::STATE_LOADED_MIXED_DISPLAY_CONTENT));
           }
         }
       }
     }
 
     return NS_OK;
   }
 private:
@@ -884,17 +877,16 @@ nsMixedContentBlocker::ShouldLoad(bool a
       *aDecision = nsIContentPolicy::ACCEPT;
       return NS_OK;
     }
   }
 
   // Get the root document from the sameTypeRoot
   nsCOMPtr<nsIDocument> rootDoc = sameTypeRoot->GetDocument();
   NS_ASSERTION(rootDoc, "No root document from document shell root tree item.");
-  ContentBlockingLog* contentBlockingLog = rootDoc->GetContentBlockingLog();
 
   // Get eventSink and the current security state from the docShell
   nsCOMPtr<nsISecurityEventSink> eventSink = do_QueryInterface(docShell);
   NS_ASSERTION(eventSink, "No eventSink from docShell.");
   nsCOMPtr<nsIDocShell> rootShell = do_GetInterface(sameTypeRoot);
   NS_ASSERTION(rootShell, "No root docshell from document shell root tree item.");
   uint32_t state = nsIWebProgressListener::STATE_IS_BROKEN;
   nsCOMPtr<nsISecureBrowserUI> securityUI;
@@ -970,36 +962,31 @@ nsMixedContentBlocker::ShouldLoad(bool a
         // set state security flag to broken, since there is mixed content
         state |= nsIWebProgressListener::STATE_IS_BROKEN;
 
         // If mixed active content is loaded, make sure to include that in the state.
         if (rootDoc->GetHasMixedActiveContentLoaded()) {
           state |= nsIWebProgressListener::STATE_LOADED_MIXED_ACTIVE_CONTENT;
         }
 
-        eventSink->OnSecurityChange(aRequestingContext, state,
-                                    (state | nsIWebProgressListener::STATE_LOADED_MIXED_DISPLAY_CONTENT),
-                                    contentBlockingLog);
+        eventSink->OnSecurityChange(aRequestingContext,
+                                    (state | nsIWebProgressListener::STATE_LOADED_MIXED_DISPLAY_CONTENT));
       } else {
         // User has overriden the pref and the root is not https;
         // mixed display content was allowed on an https subframe.
         if (NS_SUCCEEDED(stateRV)) {
-          eventSink->OnSecurityChange(aRequestingContext, state,
-                                      (state | nsIWebProgressListener::STATE_LOADED_MIXED_DISPLAY_CONTENT),
-                                      contentBlockingLog);
+          eventSink->OnSecurityChange(aRequestingContext, (state | nsIWebProgressListener::STATE_LOADED_MIXED_DISPLAY_CONTENT));
         }
       }
     } else {
       *aDecision = nsIContentPolicy::REJECT_REQUEST;
       LogMixedContentMessage(classification, aContentLocation, rootDoc, eBlocked);
       if (!rootDoc->GetHasMixedDisplayContentBlocked() && NS_SUCCEEDED(stateRV)) {
         rootDoc->SetHasMixedDisplayContentBlocked(true);
-        eventSink->OnSecurityChange(aRequestingContext, state,
-                                    (state | nsIWebProgressListener::STATE_BLOCKED_MIXED_DISPLAY_CONTENT),
-                                    contentBlockingLog);
+        eventSink->OnSecurityChange(aRequestingContext, (state | nsIWebProgressListener::STATE_BLOCKED_MIXED_DISPLAY_CONTENT));
       }
     }
     return NS_OK;
 
   } else if (sBlockMixedScript && classification == eMixedScript) {
     // If the content is active content, and the pref says active content should be blocked, block it
     // unless the user has choosen to override the pref
     if (allowMixedContent) {
@@ -1017,47 +1004,42 @@ nsMixedContentBlocker::ShouldLoad(bool a
         // set state security flag to broken, since there is mixed content
         state |= nsIWebProgressListener::STATE_IS_BROKEN;
 
         // If mixed display content is loaded, make sure to include that in the state.
         if (rootDoc->GetHasMixedDisplayContentLoaded()) {
           state |= nsIWebProgressListener::STATE_LOADED_MIXED_DISPLAY_CONTENT;
         }
 
-        eventSink->OnSecurityChange(aRequestingContext, state,
-                                    (state | nsIWebProgressListener::STATE_LOADED_MIXED_ACTIVE_CONTENT),
-                                    contentBlockingLog);
+        eventSink->OnSecurityChange(aRequestingContext,
+                                    (state | nsIWebProgressListener::STATE_LOADED_MIXED_ACTIVE_CONTENT));
 
         return NS_OK;
       } else {
         // User has already overriden the pref and the root is not https;
         // mixed active content was allowed on an https subframe.
         if (NS_SUCCEEDED(stateRV)) {
-          eventSink->OnSecurityChange(aRequestingContext, state,
-                                      (state | nsIWebProgressListener::STATE_LOADED_MIXED_ACTIVE_CONTENT),
-                                      contentBlockingLog);
+          eventSink->OnSecurityChange(aRequestingContext, (state | nsIWebProgressListener::STATE_LOADED_MIXED_ACTIVE_CONTENT));
         }
         return NS_OK;
       }
     } else {
       //User has not overriden the pref by Disabling protection. Reject the request and update the security state.
       *aDecision = nsIContentPolicy::REJECT_REQUEST;
       LogMixedContentMessage(classification, aContentLocation, rootDoc, eBlocked);
       // See if the pref will change here. If it will, only then do we need to call OnSecurityChange() to update the UI.
       if (rootDoc->GetHasMixedActiveContentBlocked()) {
         return NS_OK;
       }
       rootDoc->SetHasMixedActiveContentBlocked(true);
 
       // The user has not overriden the pref, so make sure they still have an option by calling eventSink
       // which will invoke the doorhanger
       if (NS_SUCCEEDED(stateRV)) {
-         eventSink->OnSecurityChange(aRequestingContext, state,
-                                     (state | nsIWebProgressListener::STATE_BLOCKED_MIXED_ACTIVE_CONTENT),
-                                     contentBlockingLog);
+         eventSink->OnSecurityChange(aRequestingContext, (state | nsIWebProgressListener::STATE_BLOCKED_MIXED_ACTIVE_CONTENT));
       }
       return NS_OK;
     }
   } else {
     // The content is not blocked by the mixed content prefs.
 
     // Log a message that we are loading mixed content.
     LogMixedContentMessage(classification, aContentLocation, rootDoc, eUserOverride);
--- a/dom/workers/test/mochitest.ini
+++ b/dom/workers/test/mochitest.ini
@@ -192,10 +192,9 @@ scheme=https
 [test_navigator_workers_hardwareConcurrency.html]
 [test_bug1278777.html]
 [test_setTimeoutWith0.html]
 [test_bug1301094.html]
 [test_subworkers_suspended.html]
 skip-if = toolkit == 'android' #bug 1366501
 [test_bug1317725.html]
 [test_sharedworker_event_listener_leaks.html]
-skip-if = (bits == 64 && os == 'linux' && asan && !debug) # Disabled on Linux64 opt asan, bug 1493563
 [test_fileReaderSync_when_closing.html]
--- a/editor/composer/nsEditingSession.cpp
+++ b/editor/composer/nsEditingSession.cpp
@@ -808,20 +808,17 @@ nsEditingSession::OnStatusChange(nsIWebP
 
 /*---------------------------------------------------------------------------
 
   OnSecurityChange
 
 ----------------------------------------------------------------------------*/
 NS_IMETHODIMP
 nsEditingSession::OnSecurityChange(nsIWebProgress *aWebProgress,
-                                   nsIRequest *aRequest,
-                                   uint32_t aOldState,
-                                   uint32_t aState,
-                                   const nsAString& aContentBlockingLogJSON)
+                                   nsIRequest *aRequest, uint32_t state)
 {
     MOZ_ASSERT_UNREACHABLE("notification excluded in AddProgressListener(...)");
     return NS_OK;
 }
 
 
 /*---------------------------------------------------------------------------
 
--- a/editor/composer/test/test_bug434998.xul
+++ b/editor/composer/test/test_bug434998.xul
@@ -82,18 +82,17 @@ https://bugzilla.mozilla.org/show_bug.cg
     onLocationChange : function(aWebProgress, aRequest, aLocation, aFlags)
     {
     },
 
     onStatusChange : function(aWebProgress, aRequest, aStatus, aMessage)
     {
     },
 
-    onSecurityChange : function(aWebProgress, aRequest, aOldState, aState,
-                                aContentBlockingLogJSON)
+    onSecurityChange : function(aWebProgress, aRequest, aState)
     {
     },
 
     mEditor: null
   };
 
   var progress, progressListener;
 
--- a/editor/libeditor/tests/test_bug607584.xul
+++ b/editor/libeditor/tests/test_bug607584.xul
@@ -88,18 +88,17 @@ https://bugzilla.mozilla.org/show_bug.cg
     onLocationChange : function(aWebProgress, aRequest, aLocation, aFlags)
       {
       },
   
     onStatusChange : function(aWebProgress, aRequest, aStatus, aMessage)
       {
       },
   
-    onSecurityChange : function(aWebProgress, aRequest, aOldState, aState,
-                                aContentBlockingLogJSON)
+    onSecurityChange : function(aWebProgress, aRequest, aState)
       {
       },
   
       mEditor: null
   };
 
   var progress, progressListener;
 
--- a/editor/libeditor/tests/test_bug616590.xul
+++ b/editor/libeditor/tests/test_bug616590.xul
@@ -77,18 +77,17 @@ https://bugzilla.mozilla.org/show_bug.cg
     onLocationChange : function(aWebProgress, aRequest, aLocation, aFlags)
     {
     },
 
     onStatusChange : function(aWebProgress, aRequest, aStatus, aMessage)
     {
     },
 
-    onSecurityChange : function(aWebProgress, aRequest, aOldState, aState,
-                                aContentBlockingLogJSON)
+    onSecurityChange : function(aWebProgress, aRequest, aState)
     {
     },
 
     mEditor: null
   };
 
   var progress, progressListener;
 
--- a/editor/libeditor/tests/test_bug780908.xul
+++ b/editor/libeditor/tests/test_bug780908.xul
@@ -86,18 +86,17 @@ adapted from test_bug607584.xul by Kent 
     onLocationChange : function(aWebProgress, aRequest, aLocation, aFlags)
       {
       },
   
     onStatusChange : function(aWebProgress, aRequest, aStatus, aMessage)
       {
       },
   
-    onSecurityChange : function(aWebProgress, aRequest, aOldState, aState,
-                                aContentBlockingLogJSON)
+    onSecurityChange : function(aWebProgress, aRequest, aState)
       {
       },
   
       mEditor: null
   };
 
   var progress, progressListener;
 
--- a/layout/base/tests/chrome/printpreview_bug396024_helper.xul
+++ b/layout/base/tests/chrome/printpreview_bug396024_helper.xul
@@ -18,18 +18,17 @@ var SimpleTest = window.opener.wrappedJS
 var gWbp;
 function printpreview() {
   gWbp = window.frames[1].docShell.printPreview;
   var listener = {
     onLocationChange: function(webProgress, request, location, flags) { },
     onProgressChange: function(webProgress, request, curSelfProgress, 
                                maxSelfProgress, curTotalProgress,
                                maxTotalProgress) { },
-    onSecurityChange: function(webProgress, request, oldState, state,
-                               contentBlockingLogJSON) { },
+    onSecurityChange: function(webProgress, request, state) { },
     onStateChange: function(webProgress, request, stateFlags, status) { },
     onStatusChange: function(webProgress, request, status, message) { },
     QueryInterface: function(iid) {
       if (iid.equals(Ci.nsIWebProgressListener) ||
           iid.equals(Ci.nsISupportsWeakReference))
             return this;
       throw Cr.NS_NOINTERFACE;
     }
--- a/layout/base/tests/chrome/printpreview_bug482976_helper.xul
+++ b/layout/base/tests/chrome/printpreview_bug482976_helper.xul
@@ -18,18 +18,17 @@ var SimpleTest = window.opener.wrappedJS
 var gWbp;
 function printpreview() {
   gWbp = window.frames[1].docShell.printPreview;
   var listener = {
     onLocationChange: function(webProgress, request, location, flags) { },
     onProgressChange: function(webProgress, request, curSelfProgress, 
                                maxSelfProgress, curTotalProgress,
                                maxTotalProgress) { },
-    onSecurityChange: function(webProgress, request, oldState, state,
-                               contentBlockingLogJSON) { },
+    onSecurityChange: function(webProgress, request, state) { },
     onStateChange: function(webProgress, request, stateFlags, status) { },
     onStatusChange: function(webProgress, request, status, message) { },
     QueryInterface: function(iid) {
       if (iid.equals(Ci.nsIWebProgessListener) ||
           iid.equals(Ci.nsISupportsWeakReference))
             return this;
       throw Cr.NS_NOINTERFACE;
     }
--- a/layout/base/tests/chrome/printpreview_helper.xul
+++ b/layout/base/tests/chrome/printpreview_helper.xul
@@ -25,18 +25,17 @@ filePath = file.path;
 
 function printpreview() {
   gWbp = window.frames[1].docShell.printPreview;
   var listener = {
     onLocationChange: function(webProgress, request, location, flags) { },
     onProgressChange: function(webProgress, request, curSelfProgress, 
                                maxSelfProgress, curTotalProgress,
                                maxTotalProgress) { },
-    onSecurityChange: function(webProgress, request, oldState, state,
-                               contentBlockingLogJSON) { },
+    onSecurityChange: function(webProgress, request, state) { },
     onStateChange: function(webProgress, request, stateFlags, status) { },
     onStatusChange: function(webProgress, request, status, message) { },
     QueryInterface: function(iid) {
       if (iid.equals(Ci.nsIWebProgressListener) ||
           iid.equals(Ci.nsISupportsWeakReference))
             return this;
       throw Cr.NS_NOINTERFACE;
     }
--- a/layout/printing/ipc/RemotePrintJobChild.cpp
+++ b/layout/printing/ipc/RemotePrintJobChild.cpp
@@ -158,20 +158,17 @@ RemotePrintJobChild::OnStatusChange(nsIW
     Unused << SendStatusChange(aStatus);
   }
 
   return NS_OK;
 }
 
 NS_IMETHODIMP
 RemotePrintJobChild::OnSecurityChange(nsIWebProgress* aProgress,
-                                      nsIRequest* aRequest,
-                                      uint32_t aState,
-                                      uint32_t aOldState,
-                                      const nsAString& aContentBlockingLogJSON)
+                                      nsIRequest* aRequest, uint32_t aState)
 {
   return NS_OK;
 }
 
 // End of nsIWebProgressListener
 
 RemotePrintJobChild::~RemotePrintJobChild()
 {
--- a/layout/printing/nsPrintJob.cpp
+++ b/layout/printing/nsPrintJob.cpp
@@ -2111,19 +2111,17 @@ nsPrintJob::OnStatusChange(nsIWebProgres
 {
   MOZ_ASSERT_UNREACHABLE("notification excluded in AddProgressListener(...)");
   return NS_OK;
 }
 
 NS_IMETHODIMP
 nsPrintJob::OnSecurityChange(nsIWebProgress* aWebProgress,
                              nsIRequest* aRequest,
-                             uint32_t aState,
-                             uint32_t aOldState,
-                             const nsAString& aContentBlockingLogJSON)
+                             uint32_t aState)
 {
   MOZ_ASSERT_UNREACHABLE("notification excluded in AddProgressListener(...)");
   return NS_OK;
 }
 
 //-------------------------------------------------------
 
 void
--- a/layout/tools/layout-debug/ui/content/layoutdebug.js
+++ b/layout/tools/layout-debug/ui/content/layoutdebug.js
@@ -72,18 +72,17 @@ nsLDBBrowserContentListener.prototype = 
       this.setButtonEnabled(this.mBackButton, gBrowser.canGoBack);
     },
 
   onStatusChange : function(aWebProgress, aRequest, aStatus, aMessage)
     {
       this.mStatusText.value = aMessage;
     },
 
-  onSecurityChange : function(aWebProgress, aRequest, aOldState, aState,
-                              aContentBlockingLogJSON)
+  onSecurityChange : function(aWebProgress, aRequest, aState)
     {
     },
 
   // non-interface methods
   setButtonEnabled : function(aButtonElement, aEnabled)
     {
       if (aEnabled)
         aButtonElement.removeAttribute("disabled");
--- a/mobile/android/chrome/content/browser.js
+++ b/mobile/android/chrome/content/browser.js
@@ -4699,18 +4699,17 @@ Tab.prototype = {
       Services.obs.notifyObservers(this.browser, "Session:NotifyLocationChange");
     }
   },
 
   // Properties used to cache security state used to update the UI
   _state: null,
   _hostChanged: false, // onLocationChange will flip this bit
 
-  onSecurityChange: function(aWebProgress, aRequest, aOldState, aState,
-                             aContentBlockingLogJSON) {
+  onSecurityChange: function(aWebProgress, aRequest, aState) {
     // Don't need to do anything if the data we use to update the UI hasn't changed
     if (this._state == aState && !this._hostChanged)
       return;
 
     this._state = aState;
     this._hostChanged = false;
 
     let identity = IdentityHandler.checkIdentity(aState, this.browser);
--- a/mobile/android/modules/geckoview/GeckoViewProgress.jsm
+++ b/mobile/android/modules/geckoview/GeckoViewProgress.jsm
@@ -247,18 +247,17 @@ class GeckoViewProgress extends GeckoVie
         type: "GeckoView:PageStop",
         success: isSuccess
       };
 
       this.eventDispatcher.sendRequest(message);
     }
   }
 
-  onSecurityChange(aWebProgress, aRequest, aOldState, aState,
-                   aContentBlockingLogJSON) {
+  onSecurityChange(aWebProgress, aRequest, aState) {
     debug `onSecurityChange`;
 
     // Don't need to do anything if the data we use to update the UI hasn't changed
     if (this._state === aState && !this._hostChanged) {
       return;
     }
 
     this._state = aState;
--- a/mobile/android/modules/geckoview/GeckoViewTrackingProtection.jsm
+++ b/mobile/android/modules/geckoview/GeckoViewTrackingProtection.jsm
@@ -15,18 +15,17 @@ class GeckoViewTrackingProtection extend
     const flags = Ci.nsIWebProgress.NOTIFY_SECURITY;
     this.progressFilter =
       Cc["@mozilla.org/appshell/component/browser-status-filter;1"]
       .createInstance(Ci.nsIWebProgress);
     this.progressFilter.addProgressListener(this, flags);
     this.browser.addProgressListener(this.progressFilter, flags);
   }
 
-  onSecurityChange(aWebProgress, aRequest, aOldState, aState,
-                   aContentBlockingLogJSON) {
+  onSecurityChange(aWebProgress, aRequest, aState) {
     debug `onSecurityChange`;
 
     if (!(aState & Ci.nsIWebProgressListener.STATE_BLOCKED_TRACKING_CONTENT) ||
         !aRequest || !(aRequest instanceof Ci.nsIClassifiedChannel)) {
       return;
     }
 
     let channel = aRequest.QueryInterface(Ci.nsIChannel);
--- a/modules/libpref/init/StaticPrefList.h
+++ b/modules/libpref/init/StaticPrefList.h
@@ -1617,24 +1617,16 @@ VARCACHE_PREF(
 )
 
 VARCACHE_PREF(
   "browser.contentblocking.allowlist.annotations.enabled",
    browser_contentblocking_allowlist_annotations_enabled,
   bool, true
 )
 
-// How many recent block/unblock actions per origins we remember in the
-// Content Blocking log for each top-level window.
-VARCACHE_PREF(
-  "browser.contentblocking.originlog.length",
-   browser_contentblocking_originlog_length,
-  uint32_t, 32
-)
-
 // Whether FastBlock has been enabled.
 VARCACHE_PREF(
   "browser.fastblock.enabled",
   browser_fastblock_enabled,
   bool, false
 )
 
 // Anti-tracking permission expiration
--- a/netwerk/base/nsChannelClassifier.cpp
+++ b/netwerk/base/nsChannelClassifier.cpp
@@ -618,19 +618,18 @@ nsChannelClassifier::NotifyTrackingProte
     uint32_t state = 0;
     nsCOMPtr<nsISecureBrowserUI> securityUI;
     docShell->GetSecurityUI(getter_AddRefs(securityUI));
     if (!securityUI) {
       return NS_OK;
     }
     doc->SetHasTrackingContentLoaded(true);
     securityUI->GetState(&state);
-    const uint32_t oldState = state;
     state |= nsIWebProgressListener::STATE_LOADED_TRACKING_CONTENT;
-    eventSink->OnSecurityChange(nullptr, oldState, state, doc->GetContentBlockingLog());
+    eventSink->OnSecurityChange(nullptr, state);
 
     return NS_OK;
 }
 
 void
 nsChannelClassifier::Start()
 {
   nsresult rv = StartInternal();
--- a/netwerk/base/nsISecureBrowserUI.idl
+++ b/netwerk/base/nsISecureBrowserUI.idl
@@ -9,40 +9,15 @@
 interface nsIDocShell;
 interface nsITransportSecurityInfo;
 
 [scriptable, uuid(718c662a-f810-4a80-a6c9-0b1810ecade2)]
 interface nsISecureBrowserUI : nsISupports
 {
     void init(in nsIDocShell docShell);
 
-    // A value composed of the Security State Flags and the Security
-    // Strength Flags defined in nsIWebProgressListener.
-    // Any undefined bits are reserved for future use.
-    // This represents the security state before the change.
-    readonly attribute unsigned long oldState;
-    // A value composed of the Security State Flags and the Security
-    // Strength Flags defined in nsIWebProgressListener.
-    // Any undefined bits are reserved for future use.
-    // This represents the security state after the change.
     readonly attribute unsigned long state;
-    // An optional JSON string representing a log of the content blocking
-    // events happened so far.  This will be a JSON object containing keys
-    // representing origins that content blocking has acted on, with values
-    // being an array of items, each representing one action.  Each action
-    // itself is an an array containing three elements, the first element
-    // being a blocking code from one of the Security State Flags above, and
-    // the second element being a boolean representing whether the origin
-    // was blocked (if true) or unblocked (if false) in that category, and
-    // the third element being the number of times that combination has been
-    // repeated consecutively.
-    // The reason JSON strings was chosen here was that we needed a format
-    // that is transferrable across processes in JS; and also the consumer
-    // of this data (browser-contentblocking.js) would be able to use the
-    // JSON.parse() API to parse out an object representation of the value.
-    readonly attribute AString contentBlockingLogJSON;
-    // Information about the connection security.
     readonly attribute nsITransportSecurityInfo secInfo;
 };
 
 %{C++
 #define NS_SECURE_BROWSER_UI_CONTRACTID "@mozilla.org/secure_browser_ui;1"
 %}
--- a/netwerk/base/nsISecurityEventSink.idl
+++ b/netwerk/base/nsISecurityEventSink.idl
@@ -1,39 +1,26 @@
 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #include "nsISupports.idl"
+interface nsIURI;
 
-%{ C++
-namespace mozilla {
-namespace dom {
-class ContentBlockingLog;
-}
-}
-%}
-
-[ptr] native ContentBlockingLog(mozilla::dom::ContentBlockingLog);
-
-[builtinclass, uuid(a71aee68-dd38-4736-bd79-035fea1a1ec6)]
+[scriptable, uuid(a71aee68-dd38-4736-bd79-035fea1a1ec6)]
 interface nsISecurityEventSink : nsISupports
 {
 
     /**
       * Fired when a security change occurs due to page transitions,
       * or end document load. This interface should be called by
       * a security package (eg Netscape Personal Security Manager)
       * to notify nsIWebProgressListeners that security state has
       * changed. State flags are in nsIWebProgressListener.idl
-      * The old state flags before the change must also be passed in.
-      * cbLog represents the log of the content blocking actions on
-      * the page so far.
       */
 
-    void onSecurityChange(in nsISupports i_Context, in unsigned long oldState,
-                          in unsigned long state, in ContentBlockingLog cbLog);
+    void onSecurityChange(in nsISupports i_Context, in unsigned long state);
 };
 
 
 
 
--- a/security/manager/ssl/nsSecureBrowserUIImpl.cpp
+++ b/security/manager/ssl/nsSecureBrowserUIImpl.cpp
@@ -16,18 +16,17 @@
 #include "nsITransportSecurityInfo.h"
 #include "nsIWebProgress.h"
 
 using namespace mozilla;
 
 LazyLogModule gSecureBrowserUILog("nsSecureBrowserUI");
 
 nsSecureBrowserUIImpl::nsSecureBrowserUIImpl()
-  : mOldState(0)
-  , mState(0)
+  : mState(0)
 {
   MOZ_ASSERT(NS_IsMainThread());
 }
 
 NS_IMPL_ISUPPORTS(nsSecureBrowserUIImpl,
                   nsISecureBrowserUI,
                   nsIWebProgressListener,
                   nsISupportsWeakReference)
@@ -58,30 +57,16 @@ nsSecureBrowserUIImpl::Init(nsIDocShell*
   if (NS_FAILED(rv)) {
     return rv;
   }
 
   return wp->AddProgressListener(this, nsIWebProgress::NOTIFY_LOCATION);
 }
 
 NS_IMETHODIMP
-nsSecureBrowserUIImpl::GetOldState(uint32_t* aOldState)
-{
-  MOZ_ASSERT(NS_IsMainThread());
-  NS_ENSURE_ARG(aOldState);
-
-  MOZ_LOG(gSecureBrowserUILog, LogLevel::Debug, ("GetOldState %p", this));
-  // Only sync our state with the docshell in GetState().
-  MOZ_LOG(gSecureBrowserUILog, LogLevel::Debug, ("  mOldState: %x", mOldState));
-
-  *aOldState = mOldState;
-  return NS_OK;
-}
-
-NS_IMETHODIMP
 nsSecureBrowserUIImpl::GetState(uint32_t* aState)
 {
   MOZ_ASSERT(NS_IsMainThread());
   NS_ENSURE_ARG(aState);
 
   MOZ_LOG(gSecureBrowserUILog, LogLevel::Debug, ("GetState %p", this));
   // With respect to mixed content and tracking protection, we won't know when
   // the state of our document (or a subdocument) has changed, so we ask the
@@ -89,36 +74,16 @@ nsSecureBrowserUIImpl::GetState(uint32_t
   CheckForBlockedContent();
   MOZ_LOG(gSecureBrowserUILog, LogLevel::Debug, ("  mState: %x", mState));
 
   *aState = mState;
   return NS_OK;
 }
 
 NS_IMETHODIMP
-nsSecureBrowserUIImpl::GetContentBlockingLogJSON(nsAString& aContentBlockingLogJSON)
-{
-  MOZ_ASSERT(NS_IsMainThread());
-
-  MOZ_LOG(gSecureBrowserUILog, LogLevel::Debug, ("GetContentBlockingLogJSON %p", this));
-  aContentBlockingLogJSON.Truncate();
-  nsCOMPtr<nsIDocShell> docShell = do_QueryReferent(mDocShell);
-  if (docShell) {
-    nsIDocument* doc = docShell->GetDocument();
-    if (doc) {
-      aContentBlockingLogJSON = doc->GetContentBlockingLog()->Stringify();
-    }
-  }
-  MOZ_LOG(gSecureBrowserUILog, LogLevel::Debug,
-          ("  ContentBlockingLogJSON: %s", NS_ConvertUTF16toUTF8(aContentBlockingLogJSON).get()));
-
-  return NS_OK;
-}
-
-NS_IMETHODIMP
 nsSecureBrowserUIImpl::GetSecInfo(nsITransportSecurityInfo** result)
 {
   MOZ_ASSERT(NS_IsMainThread());
   NS_ENSURE_ARG_POINTER(result);
 
   *result = mTopLevelSecurityInfo;
   NS_IF_ADDREF(*result);
 
@@ -145,18 +110,16 @@ nsSecureBrowserUIImpl::CheckForBlockedCo
       sameTypeRoot,
       "No document shell root tree item from document shell tree item!");
     docShell = do_QueryInterface(sameTypeRoot);
     if (!docShell) {
       return;
     }
   }
 
-  mOldState = mState;
-
   // Has mixed content been loaded or blocked in nsMixedContentBlocker?
   // This only applies to secure documents.
   if (mState & STATE_IS_SECURE) {
     if (docShell->GetHasMixedActiveContentLoaded()) {
       mState |= STATE_IS_BROKEN | STATE_LOADED_MIXED_ACTIVE_CONTENT;
       mState &= ~STATE_IS_SECURE;
       mState &= ~STATE_SECURE_HIGH;
     }
@@ -312,17 +275,16 @@ nsSecureBrowserUIImpl::OnLocationChange(
   // initialized with.
   nsCOMPtr<nsIWebProgress> originalWebProgress = do_QueryReferent(mWebProgress);
   if (aWebProgress != originalWebProgress) {
     return NS_OK;
   }
 
   // Clear any state that varies by location.
   if (!(aFlags & LOCATION_CHANGE_SAME_DOCUMENT)) {
-    mOldState = 0;
     mState = 0;
     mTopLevelSecurityInfo = nullptr;
   }
 
   // NB: aRequest may be null. It may also not be QI-able to nsIChannel.
   nsCOMPtr<nsIChannel> channel(do_QueryInterface(aRequest));
   if (channel) {
     MOZ_LOG(gSecureBrowserUILog, LogLevel::Debug,
@@ -332,28 +294,19 @@ nsSecureBrowserUIImpl::OnLocationChange(
       return rv;
     }
 
     nsCOMPtr<nsISecurityEventSink> eventSink;
     NS_QueryNotificationCallbacks(channel, eventSink);
     if (NS_WARN_IF(!eventSink)) {
       return NS_ERROR_INVALID_ARG;
     }
-    mozilla::dom::ContentBlockingLog* contentBlockingLog = nullptr;
-    nsCOMPtr<nsIDocShell> docShell = do_QueryReferent(mDocShell);
-    if (docShell) {
-      nsIDocument* doc = docShell->GetDocument();
-      if (doc) {
-        contentBlockingLog = doc->GetContentBlockingLog();
-      }
-    }
     MOZ_LOG(gSecureBrowserUILog, LogLevel::Debug,
             ("  calling OnSecurityChange %p %x\n", aRequest, mState));
-    Unused << eventSink->OnSecurityChange(aRequest, mOldState, mState,
-                                          contentBlockingLog);
+    Unused << eventSink->OnSecurityChange(aRequest, mState);
   }
 
   return NS_OK;
 }
 
 NS_IMETHODIMP
 nsSecureBrowserUIImpl::OnStateChange(nsIWebProgress*,
                                      nsIRequest*,
@@ -382,14 +335,13 @@ nsSecureBrowserUIImpl::OnStatusChange(ns
                                       nsresult,
                                       const char16_t*)
 {
   MOZ_ASSERT_UNREACHABLE("Should have been excluded in AddProgressListener()");
   return NS_OK;
 }
 
 nsresult
-nsSecureBrowserUIImpl::OnSecurityChange(nsIWebProgress*, nsIRequest*, uint32_t,
-                                        uint32_t, const nsAString&)
+nsSecureBrowserUIImpl::OnSecurityChange(nsIWebProgress*, nsIRequest*, uint32_t)
 {
   MOZ_ASSERT_UNREACHABLE("Should have been excluded in AddProgressListener()");
   return NS_OK;
 }
--- a/security/manager/ssl/nsSecureBrowserUIImpl.h
+++ b/security/manager/ssl/nsSecureBrowserUIImpl.h
@@ -26,22 +26,21 @@ public:
 
   NS_DECL_ISUPPORTS
   NS_DECL_NSIWEBPROGRESSLISTENER
   NS_DECL_NSISECUREBROWSERUI
 
 protected:
   virtual ~nsSecureBrowserUIImpl() {};
 
-  // Do mixed content and tracking protection checks. May update mState and mOldState.
+  // Do mixed content and tracking protection checks. May update mState.
   void CheckForBlockedContent();
   // Given some information about a request from an OnLocationChange event,
-  // update mState, mOldState and mTopLevelSecurityInfo.
+  // update mState and mTopLevelSecurityInfo.
   nsresult UpdateStateAndSecurityInfo(nsIChannel* channel, nsIURI* uri);
 
-  uint32_t mOldState;
   uint32_t mState;
   nsWeakPtr mDocShell;
   nsWeakPtr mWebProgress;
   nsCOMPtr<nsITransportSecurityInfo> mTopLevelSecurityInfo;
 };
 
 #endif // nsSecureBrowserUIImpl_h
--- a/toolkit/actors/PrintingChild.jsm
+++ b/toolkit/actors/PrintingChild.jsm
@@ -416,11 +416,10 @@ PrintingListener.prototype = {
       maxSelfProgress: aMaxSelfProgress,
       curTotalProgress: aCurTotalProgress,
       maxTotalProgress: aMaxTotalProgress,
     });
   },
 
   onLocationChange(aWebProgress, aRequest, aLocation, aFlags) {},
   onStatusChange(aWebProgress, aRequest, aStatus, aMessage) {},
-  onSecurityChange(aWebProgress, aRequest, aOldState, aState,
-                   aContentBlockingLogJSON) {},
+  onSecurityChange(aWebProgress, aRequest, aState) {},
 };
--- a/toolkit/components/antitracking/AntiTrackingCommon.cpp
+++ b/toolkit/components/antitracking/AntiTrackingCommon.cpp
@@ -194,20 +194,20 @@ CheckContentBlockingAllowList(nsIHttpCha
   }
 
   LOG(("Could not check the content blocking allow list because the top "
        "window wasn't accessible"));
   return false;
 }
 
 void
-ReportBlockingToConsole(nsPIDOMWindowOuter* aWindow, nsIURI* aURI,
+ReportBlockingToConsole(nsPIDOMWindowOuter* aWindow, nsIHttpChannel* aChannel,
                         uint32_t aRejectedReason)
 {
-  MOZ_ASSERT(aWindow && aURI);
+  MOZ_ASSERT(aWindow && aChannel);
   MOZ_ASSERT(aRejectedReason == nsIWebProgressListener::STATE_COOKIES_BLOCKED_BY_PERMISSION ||
              aRejectedReason == nsIWebProgressListener::STATE_COOKIES_BLOCKED_TRACKER ||
              aRejectedReason == nsIWebProgressListener::STATE_COOKIES_BLOCKED_ALL ||
              aRejectedReason == nsIWebProgressListener::STATE_COOKIES_BLOCKED_FOREIGN ||
              aRejectedReason == nsIWebProgressListener::STATE_BLOCKED_SLOW_TRACKING_CONTENT);
 
   if (!AntiTrackingCommon::ShouldHonorContentBlockingCookieRestrictions()) {
     return;
@@ -246,17 +246,19 @@ ReportBlockingToConsole(nsPIDOMWindowOut
       break;
 
     default:
       return;
   }
 
   MOZ_ASSERT(message);
 
-  NS_ConvertUTF8toUTF16 spec(aURI->GetSpecOrDefault());
+  nsCOMPtr<nsIURI> uri;
+  aChannel->GetURI(getter_AddRefs(uri));
+  NS_ConvertUTF8toUTF16 spec(uri->GetSpecOrDefault());
   const char16_t* params[] = { spec.get() };
 
   nsContentUtils::ReportToConsole(nsIScriptError::warningFlag,
                                   NS_LITERAL_CSTRING("Content Blocking"),
                                   doc,
                                   nsContentUtils::eNECKO_PROPERTIES,
                                   message,
                                   params, ArrayLength(params));
@@ -320,42 +322,16 @@ ReportUnblockingConsole(nsPIDOMWindowInn
                                     NS_LITERAL_CSTRING("Content Blocking"),
                                     doc,
                                     nsContentUtils::eNECKO_PROPERTIES,
                                     messageWithDifferentOrigin,
                                     params, 3);
   }
 }
 
-already_AddRefed<nsPIDOMWindowOuter>
-GetTopWindow(nsPIDOMWindowInner* aWindow)
-{
-  nsIDocument* document = aWindow->GetExtantDoc();
-  if (!document) {
-    return nullptr;
-  }
-
-  nsIChannel* channel = document->GetChannel();
-  if (!channel) {
-    return nullptr;
-  }
-
-  nsCOMPtr<nsPIDOMWindowOuter> pwin;
-  auto* outer = nsGlobalWindowOuter::Cast(aWindow->GetOuterWindow());
-  if (outer) {
-    pwin = outer->GetTopOuter();
-  }
-
-  if (!pwin) {
-    return nullptr;
-  }
-
-  return pwin.forget();
-}
-
 } // anonymous
 
 /* static */ bool
 AntiTrackingCommon::ShouldHonorContentBlockingCookieRestrictions()
 {
   return StaticPrefs::browser_contentblocking_enabled();
 }
 
@@ -411,40 +387,19 @@ AntiTrackingCommon::AddFirstPartyStorage
   // We are a 3rd party source.
   } else if (!GetParentPrincipalAndTrackingOrigin(parentWindow,
                                                   getter_AddRefs(topLevelStoragePrincipal),
                                                   trackingOrigin)) {
     LOG(("Error while computing the parent principal and tracking origin, bailing out early"));
     return StorageAccessGrantPromise::CreateAndReject(false, __func__);
   }
 
-  nsCOMPtr<nsIURI> uri;
-  nsresult rv = NS_NewURI(getter_AddRefs(uri), trackingOrigin);
-  if (NS_WARN_IF(NS_FAILED(rv))) {
-    LOG(("Couldn't make a new URI out of the tracking origin"));
-    return StorageAccessGrantPromise::CreateAndReject(false, __func__);
-  }
-
-  nsCOMPtr<nsPIDOMWindowOuter> pwin = GetTopWindow(parentWindow);
-  if (!pwin) {
-    LOG(("Couldn't get the top window"));
-    return StorageAccessGrantPromise::CreateAndReject(false, __func__);
-  }
-
-  nsIChannel* channel =
-    pwin->GetCurrentInnerWindow()->GetExtantDoc()->GetChannel();
-
-  // We hardcode this block reason since the first-party storage access permission
-  // is granted for the purpose of blocking trackers.
-  const uint32_t blockReason = nsIWebProgressListener::STATE_COOKIES_BLOCKED_TRACKER;
-  pwin->NotifyContentBlockingState(blockReason, channel, false, uri);
-
   NS_ConvertUTF16toUTF8 grantedOrigin(aOrigin);
 
-  ReportUnblockingConsole(parentWindow, NS_ConvertUTF8toUTF16(trackingOrigin),
+  ReportUnblockingConsole(aParentWindow, NS_ConvertUTF8toUTF16(trackingOrigin),
                           aOrigin, aReason);
 
   if (XRE_IsParentProcess()) {
     LOG(("Saving the permission: trackingOrigin=%s, grantedOrigin=%s",
          trackingOrigin.get(), grantedOrigin.get()));
 
     RefPtr<StorageAccessGrantPromise::Private> p = new StorageAccessGrantPromise::Private(__func__);
     SaveFirstPartyStorageAccessGrantedForOriginOnParentProcess(topLevelStoragePrincipal,
@@ -1098,17 +1053,18 @@ AntiTrackingCommon::NotifyRejection(nsIC
                                     uint32_t aRejectedReason)
 {
   MOZ_ASSERT(aRejectedReason == nsIWebProgressListener::STATE_COOKIES_BLOCKED_BY_PERMISSION ||
              aRejectedReason == nsIWebProgressListener::STATE_COOKIES_BLOCKED_TRACKER ||
              aRejectedReason == nsIWebProgressListener::STATE_COOKIES_BLOCKED_ALL ||
              aRejectedReason == nsIWebProgressListener::STATE_COOKIES_BLOCKED_FOREIGN ||
              aRejectedReason == nsIWebProgressListener::STATE_BLOCKED_SLOW_TRACKING_CONTENT);
 
-  if (!aChannel) {
+  nsCOMPtr<nsIHttpChannel> httpChannel = do_QueryInterface(aChannel);
+  if (!httpChannel) {
     return;
   }
 
   // Can be called in EITHER the parent or child process.
   nsCOMPtr<nsIParentChannel> parentChannel;
   NS_QueryNotificationCallbacks(aChannel, parentChannel);
   if (parentChannel) {
     // This channel is a parent-process proxy for a child process request.
@@ -1118,72 +1074,65 @@ AntiTrackingCommon::NotifyRejection(nsIC
   }
 
   nsCOMPtr<mozIThirdPartyUtil> thirdPartyUtil = services::GetThirdPartyUtil();
   if (!thirdPartyUtil) {
     return;
   }
 
   nsCOMPtr<mozIDOMWindowProxy> win;
-  nsresult rv = thirdPartyUtil->GetTopWindowForChannel(aChannel,
+  nsresult rv = thirdPartyUtil->GetTopWindowForChannel(httpChannel,
                                                        getter_AddRefs(win));
   NS_ENSURE_SUCCESS_VOID(rv);
 
   nsCOMPtr<nsPIDOMWindowOuter> pwin = nsPIDOMWindowOuter::From(win);
   if (!pwin) {
     return;
   }
 
-  nsCOMPtr<nsIURI> uri;
-  aChannel->GetURI(getter_AddRefs(uri));
+  pwin->NotifyContentBlockingState(aRejectedReason, aChannel);
 
-  pwin->NotifyContentBlockingState(aRejectedReason, aChannel, true, uri);
-
-  ReportBlockingToConsole(pwin, uri, aRejectedReason);
+  ReportBlockingToConsole(pwin, httpChannel, aRejectedReason);
 }
 
 /* static */ void
 AntiTrackingCommon::NotifyRejection(nsPIDOMWindowInner* aWindow,
                                     uint32_t aRejectedReason)
 {
   MOZ_ASSERT(aWindow);
   MOZ_ASSERT(aRejectedReason == nsIWebProgressListener::STATE_COOKIES_BLOCKED_BY_PERMISSION ||
              aRejectedReason == nsIWebProgressListener::STATE_COOKIES_BLOCKED_TRACKER ||
              aRejectedReason == nsIWebProgressListener::STATE_COOKIES_BLOCKED_ALL ||
              aRejectedReason == nsIWebProgressListener::STATE_COOKIES_BLOCKED_FOREIGN ||
              aRejectedReason == nsIWebProgressListener::STATE_BLOCKED_SLOW_TRACKING_CONTENT);
 
+  nsIDocument* document = aWindow->GetExtantDoc();
+  if (!document) {
+    return;
+  }
 
-  nsCOMPtr<nsPIDOMWindowOuter> pwin = GetTopWindow(aWindow);
+  nsCOMPtr<nsIHttpChannel> httpChannel =
+    do_QueryInterface(document->GetChannel());
+  if (!httpChannel) {
+    return;
+  }
+
+  nsCOMPtr<nsPIDOMWindowOuter> pwin;
+  auto* outer = nsGlobalWindowOuter::Cast(aWindow->GetOuterWindow());
+  if (outer) {
+    pwin = outer->GetTopOuter();
+  }
+
   if (!pwin) {
     return;
   }
 
-  nsPIDOMWindowInner* inner = pwin->GetCurrentInnerWindow();
-  if (!inner) {
-    return;
-  }
-  nsIDocument* pwinDoc = inner->GetExtantDoc();
-  if (!pwinDoc) {
-    return;
-  }
-  nsIChannel* channel = pwinDoc->GetChannel();
-  if (!channel) {
-    return;
-  }
+  pwin->NotifyContentBlockingState(aRejectedReason, httpChannel);
 
-  nsIDocument* document = aWindow->GetExtantDoc();
-  if (!document) {
-    return;
-  }
-  nsIURI* uri = document->GetDocumentURI();
-
-  pwin->NotifyContentBlockingState(aRejectedReason, channel, true, uri);
-
-  ReportBlockingToConsole(pwin, uri, aRejectedReason);
+  ReportBlockingToConsole(pwin, httpChannel, aRejectedReason);
 }
 
 /* static */ void
 AntiTrackingCommon::StoreUserInteractionFor(nsIPrincipal* aPrincipal)
 {
   if (XRE_IsParentProcess()) {
     nsCOMPtr<nsIURI> uri;
     Unused << aPrincipal->GetURI(getter_AddRefs(uri));
--- a/toolkit/components/antitracking/test/browser/browser_onModifyRequestNotificationForTrackingResources.js
+++ b/toolkit/components/antitracking/test/browser/browser_onModifyRequestNotificationForTrackingResources.js
@@ -12,17 +12,17 @@ ChromeUtils.import("resource://gre/modul
 
 let gExpectedResourcesSeen = 0;
 async function onModifyRequest() {
   return new Promise((resolve, reject) => {
     Services.obs.addObserver(function observer(subject, topic, data) {
       let httpChannel = subject.QueryInterface(Ci.nsIHttpChannel);
       let spec = httpChannel.URI.spec;
       info("Observed channel for " + spec);
-      if (httpChannel.URI.prePath != TEST_3RD_PARTY_DOMAIN_TP) {
+      if (httpChannel.URI.prePath + "/" != TEST_3RD_PARTY_DOMAIN_TP) {
         return;
       }
       if (spec.endsWith("empty.js")) {
         ok(true, "Correct resource observed");
         ++gExpectedResourcesSeen;
       } else if (spec.endsWith("empty.js?redirect")) {
         httpChannel.redirectTo(Services.io.newURI(spec.replace("empty.js?redirect", "head.js")));
       } else if (spec.endsWith("empty.js?redirect2")) {
--- a/toolkit/components/antitracking/test/browser/head.js
+++ b/toolkit/components/antitracking/test/browser/head.js
@@ -1,13 +1,13 @@
-const TEST_DOMAIN = "http://example.net";
-const TEST_3RD_PARTY_DOMAIN = "https://tracking.example.org";
-const TEST_3RD_PARTY_DOMAIN_TP = "https://tracking.example.com";
+const TEST_DOMAIN = "http://example.net/";
+const TEST_3RD_PARTY_DOMAIN = "https://tracking.example.org/";
+const TEST_3RD_PARTY_DOMAIN_TP = "https://tracking.example.com/";
 
-const TEST_PATH = "/browser/toolkit/components/antitracking/test/browser/";
+const TEST_PATH = "browser/toolkit/components/antitracking/test/browser/";
 
 const TEST_TOP_PAGE = TEST_DOMAIN + TEST_PATH + "page.html";
 const TEST_EMBEDDER_PAGE = TEST_DOMAIN + TEST_PATH + "embedder.html";
 const TEST_POPUP_PAGE = TEST_DOMAIN + TEST_PATH + "popup.html";
 const TEST_3RD_PARTY_PAGE = TEST_3RD_PARTY_DOMAIN + TEST_PATH + "3rdParty.html";
 const TEST_3RD_PARTY_PAGE_WO = TEST_3RD_PARTY_DOMAIN + TEST_PATH + "3rdPartyWO.html";
 const TEST_3RD_PARTY_PAGE_UI = TEST_3RD_PARTY_DOMAIN + TEST_PATH + "3rdPartyUI.html";
 const TEST_3RD_PARTY_PAGE_WITH_SVG = TEST_3RD_PARTY_DOMAIN + TEST_PATH + "3rdPartySVG.html";
@@ -15,17 +15,17 @@ const TEST_3RD_PARTY_PAGE_WITH_SVG = TES
 const BEHAVIOR_ACCEPT         = Ci.nsICookieService.BEHAVIOR_ACCEPT;
 const BEHAVIOR_REJECT_FOREIGN = Ci.nsICookieService.BEHAVIOR_REJECT_FOREIGN;
 const BEHAVIOR_REJECT_TRACKER = Ci.nsICookieService.BEHAVIOR_REJECT_TRACKER;
 
 var gFeatures = undefined;
 
 let {UrlClassifierTestUtils} = ChromeUtils.import("resource://testing-common/UrlClassifierTestUtils.jsm", {});
 
-requestLongerTimeout(5);
+requestLongerTimeout(3);
 
 this.AntiTracking = {
   runTest(name, callbackTracking, callbackNonTracking, cleanupFunction, extraPrefs,
           windowOpenTest = true, userInteractionTest = true, expectedBlockingNotifications = true,
           runInPrivateWindow = false, iframeSandbox = null) {
     // Here we want to test that a 3rd party context is simply blocked.
     this._createTask({
       name,
@@ -536,18 +536,17 @@ this.AntiTracking = {
                                    runInPrivateWindow, iframeSandbox, extraPrefs);
         this._createCleanupTask(cleanupFunction);
       }
 
       // Phase 3: Here we want to test that a third-party context doesn't
       // get blocked with user interaction present
       if (userInteractionTest) {
         this._createUserInteractionTask(name, callbackTracking, callbackNonTracking,
-                                        runInPrivateWindow, iframeSandbox,
-                                        expectedBlockingNotifications, extraPrefs);
+                                        runInPrivateWindow, iframeSandbox, extraPrefs);
         this._createCleanupTask(cleanupFunction);
       }
     }
   },
 
   async _setupTest(win, cookieBehavior, blockingByContentBlocking,
                    blockingByContentBlockingUI, blockingByContentBlockingRTUI,
                    extraPrefs) {
@@ -591,76 +590,20 @@ this.AntiTracking = {
       await AntiTracking._setupTest(win, options.cookieBehavior,
                                     options.blockingByContentBlocking,
                                     options.blockingByContentBlockingUI,
                                     options.blockingByContentBlockingRTUI,
                                     options.extraPrefs);
 
       let cookieBlocked = 0;
       let listener = {
-        onSecurityChange(webProgress, request, oldState, state,
-                         contentBlockingLogJSON) {
-          if (state & Ci.nsIWebProgressListener.STATE_COOKIES_BLOCKED_TRACKER) {
+        onSecurityChange(webProgress, request, stateFlags, status) {
+          if (stateFlags & Ci.nsIWebProgressListener.STATE_COOKIES_BLOCKED_TRACKER) {
             ++cookieBlocked;
           }
-          let contentBlockingLog = {};
-          try {
-            contentBlockingLog = JSON.parse(contentBlockingLogJSON);
-          } catch (e) {
-          }
-          // If this is the first cookie to be blocked, our state should have
-          // just changed, otherwise it should have previously contained the
-          // STATE_COOKIES_BLOCKED_TRACKER bit too.
-          if (options.expectedBlockingNotifications && cookieBlocked &&
-              !options.allowList) {
-            if (cookieBlocked == 1) {
-              is(oldState & Ci.nsIWebProgressListener.STATE_COOKIES_BLOCKED_TRACKER, 0,
-                 "When blocking the first cookie, old state should not have had the " +
-                 "STATE_COOKIES_BLOCKED_TRACKER bit");
-            }
-
-            let trackerOriginCount = 0;
-            for (let trackerOrigin in contentBlockingLog) {
-              ++trackerOriginCount;
-              is(trackerOrigin, TEST_3RD_PARTY_DOMAIN, "Correct tracker origin must be reported");
-              let originLog = contentBlockingLog[trackerOrigin];
-              if (originLog.length == 1) {
-                is(originLog[0][0], Ci.nsIWebProgressListener.STATE_COOKIES_BLOCKED_TRACKER,
-                   "Correct blocking type reported");
-                is(originLog[0][1], true,
-                   "Correct blocking status reported");
-                ok(originLog[0][2] >= 1,
-                   "Correct repeat count reported");
-              } else {
-                // This branch is needed here because of the tests that use the storage
-                // access API to gain storage access.
-                is(originLog.length, 2, "Correct origin log length");
-                is(originLog[0][0], Ci.nsIWebProgressListener.STATE_COOKIES_BLOCKED_TRACKER,
-                   "Correct blocking type reported");
-                is(originLog[0][1], true,
-                   "Correct blocking status reported");
-                ok(originLog[0][2] >= 1,
-                   "Correct repeat count reported");
-                is(originLog[1][0], Ci.nsIWebProgressListener.STATE_COOKIES_BLOCKED_TRACKER,
-                   "Correct blocking type reported");
-                is(originLog[1][1], false,
-                   "Correct blocking status reported");
-                is(originLog[1][2], 1,
-                   "Correct repeat count reported");
-              }
-            }
-            is(trackerOriginCount, 1, "Should only report one tracker origin");
-          }
-          if (!options.expectedBlockingNotifications) {
-            is(oldState & Ci.nsIWebProgressListener.STATE_COOKIES_BLOCKED_TRACKER, 0,
-               "When not blocking, old state should not have had the " +
-               "STATE_COOKIES_BLOCKED_TRACKER bit");
-            is(Object.keys(contentBlockingLog).length, 0,
-               "Content blocking log JSON must be empty");
-          }
         },
       };
       win.gBrowser.addProgressListener(listener);
 
       info("Creating a new tab");
       let tab = BrowserTestUtils.addTab(win.gBrowser, TEST_TOP_PAGE);
       win.gBrowser.selectedTab = tab;
 
@@ -754,71 +697,16 @@ this.AntiTracking = {
       let win = window;
       if (runInPrivateWindow) {
         win = OpenBrowserWindow({private: true});
         await TestUtils.topicObserved("browser-delayed-startup-finished");
       }
 
       await AntiTracking._setupTest(win, BEHAVIOR_REJECT_TRACKER, true, true, true, extraPrefs);
 
-      let cookieBlocked = 0;
-      let listener = {
-        onSecurityChange(webProgress, request, oldState, state,
-                         contentBlockingLogJSON) {
-          if (state & Ci.nsIWebProgressListener.STATE_COOKIES_BLOCKED_TRACKER) {
-            ++cookieBlocked;
-          }
-          let contentBlockingLog = {};
-          try {
-            contentBlockingLog = JSON.parse(contentBlockingLogJSON);
-          } catch (e) {
-          }
-          // If this is the first cookie to be blocked, our state should have
-          // just changed, otherwise it should have previously contained the
-          // STATE_COOKIES_BLOCKED_TRACKER bit too.
-          if (cookieBlocked) {
-            if (cookieBlocked == 1) {
-              is(oldState & Ci.nsIWebProgressListener.STATE_COOKIES_BLOCKED_TRACKER, 0,
-                 "When blocking the first cookie, old state should not have had the " +
-                 "STATE_COOKIES_BLOCKED_TRACKER bit");
-            }
-
-            for (let trackerOrigin in contentBlockingLog) {
-              is(trackerOrigin, TEST_3RD_PARTY_DOMAIN, "Correct tracker origin must be reported");
-              let originLog = contentBlockingLog[trackerOrigin];
-              if (originLog.length == 1) {
-                is(originLog[0][0], Ci.nsIWebProgressListener.STATE_COOKIES_BLOCKED_TRACKER,
-                   "Correct blocking type reported");
-                is(originLog[0][1], true,
-                   "Correct blocking status reported");
-                ok(originLog[0][2] >= 1,
-                   "Correct repeat count reported");
-              } else {
-                is(originLog.length, 2, "Correct origin log length");
-                is(originLog[0][0], Ci.nsIWebProgressListener.STATE_COOKIES_BLOCKED_TRACKER,
-                   "Correct blocking type reported");
-                is(originLog[0][1], true,
-                   "Correct blocking status reported");
-                ok(originLog[0][2] >= 1,
-                   "Correct repeat count reported");
-                is(originLog[1][0], Ci.nsIWebProgressListener.STATE_COOKIES_BLOCKED_TRACKER,
-                   "Correct blocking type reported");
-                is(originLog[1][1], false,
-                   "Correct blocking status reported");
-                is(originLog[1][2], 1,
-                   "Correct repeat count reported");
-              }
-            }
-            // Can't assert the number of tracker origins because we may get 0
-            // for web progress navigations coming from the window opening...
-          }
-        },
-      };
-      win.gBrowser.addProgressListener(listener);
-
       info("Creating a new tab");
       let tab = BrowserTestUtils.addTab(win.gBrowser, TEST_TOP_PAGE);
       win.gBrowser.selectedTab = tab;
 
       let browser = win.gBrowser.getBrowserForTab(tab);
       await BrowserTestUtils.browserLoaded(browser);
 
       let pageURL = TEST_3RD_PARTY_PAGE_WO;
@@ -864,96 +752,38 @@ this.AntiTracking = {
             ok(false, "Unknown message");
           });
 
           content.document.body.appendChild(ifr);
           ifr.src = obj.page;
         });
       });
 
-      win.gBrowser.removeProgressListener(listener);
-
       info("Removing the tab");
       BrowserTestUtils.removeTab(tab);
 
       if (runInPrivateWindow) {
         win.close();
       }
     });
   },
 
   _createUserInteractionTask(name, blockingCallback, nonBlockingCallback,
-                             runInPrivateWindow, iframeSandbox,
-                             expectedBlockingNotifications, extraPrefs) {
+                             runInPrivateWindow, iframeSandbox, extraPrefs) {
     add_task(async function() {
       info("Starting user-interaction test " + name);
 
       let win = window;
       if (runInPrivateWindow) {
         win = OpenBrowserWindow({private: true});
         await TestUtils.topicObserved("browser-delayed-startup-finished");
       }
 
       await AntiTracking._setupTest(win, BEHAVIOR_REJECT_TRACKER, true, true, true, extraPrefs);
 
-      let cookieBlocked = 0;
-      let listener = {
-        onSecurityChange(webProgress, request, oldState, state,
-                         contentBlockingLogJSON) {
-          if (state & Ci.nsIWebProgressListener.STATE_COOKIES_BLOCKED_TRACKER) {
-            ++cookieBlocked;
-          }
-          let contentBlockingLog = {};
-          try {
-            contentBlockingLog = JSON.parse(contentBlockingLogJSON);
-          } catch (e) {
-          }
-          // If this is the first cookie to be blocked, our state should have
-          // just changed, otherwise it should have previously contained the
-          // STATE_COOKIES_BLOCKED_TRACKER bit too.
-          if (expectedBlockingNotifications && cookieBlocked) {
-            if (cookieBlocked == 1) {
-              is(oldState & Ci.nsIWebProgressListener.STATE_COOKIES_BLOCKED_TRACKER, 0,
-                 "When blocking the first cookie, old state should not have had the " +
-                 "STATE_COOKIES_BLOCKED_TRACKER bit");
-            }
-
-            for (let trackerOrigin in contentBlockingLog) {
-              is(trackerOrigin, TEST_3RD_PARTY_DOMAIN, "Correct tracker origin must be reported");
-              let originLog = contentBlockingLog[trackerOrigin];
-              if (originLog.length == 1) {
-                is(originLog[0][0], Ci.nsIWebProgressListener.STATE_COOKIES_BLOCKED_TRACKER,
-                   "Correct blocking type reported");
-                is(originLog[0][1], true,
-                   "Correct blocking status reported");
-                ok(originLog[0][2] >= 1,
-                   "Correct repeat count reported");
-              } else {
-                is(originLog.length, 2, "Correct origin log length");
-                is(originLog[0][0], Ci.nsIWebProgressListener.STATE_COOKIES_BLOCKED_TRACKER,
-                   "Correct blocking type reported");
-                is(originLog[0][1], true,
-                   "Correct blocking status reported");
-                ok(originLog[0][2] >= 1,
-                   "Correct repeat count reported");
-                is(originLog[1][0], Ci.nsIWebProgressListener.STATE_COOKIES_BLOCKED_TRACKER,
-                   "Correct blocking type reported");
-                is(originLog[1][1], false,
-                   "Correct blocking status reported");
-                ok(originLog[1][2] >= 1,
-                   "Correct repeat count reported");
-              }
-            }
-            // Can't assert the number of tracker origins because we may get 0
-            // for web progress navigations coming from the window opening...
-          }
-        },
-      };
-      win.gBrowser.addProgressListener(listener);
-
       info("Creating a new tab");
       let tab = BrowserTestUtils.addTab(win.gBrowser, TEST_TOP_PAGE);
       win.gBrowser.selectedTab = tab;
 
       let browser = win.gBrowser.getBrowserForTab(tab);
       await BrowserTestUtils.browserLoaded(browser);
 
       info("Creating a 3rd party content");
@@ -1033,18 +863,16 @@ this.AntiTracking = {
             }
 
             ok(false, "Unknown message");
           });
           ifr.contentWindow.postMessage({ callback: obj.nonBlockingCallback }, "*");
         });
       });
 
-      win.gBrowser.removeProgressListener(listener);
-
       info("Removing the tab");
       BrowserTestUtils.removeTab(tab);
 
       if (runInPrivateWindow) {
         win.close();
       }
     });
   },
--- a/toolkit/components/browser/nsWebBrowser.cpp
+++ b/toolkit/components/browser/nsWebBrowser.cpp
@@ -828,23 +828,20 @@ nsWebBrowser::OnStatusChange(nsIWebProgr
                                              aMessage);
   }
   return NS_OK;
 }
 
 NS_IMETHODIMP
 nsWebBrowser::OnSecurityChange(nsIWebProgress* aWebProgress,
                                nsIRequest* aRequest,
-                               uint32_t aOldState,
-                               uint32_t aState,
-                               const nsAString& aContentBlockingLogJSON)
+                               uint32_t aState)
 {
   if (mProgressListener) {
-    return mProgressListener->OnSecurityChange(aWebProgress, aRequest, aOldState,
-                                               aState, aContentBlockingLogJSON);
+    return mProgressListener->OnSecurityChange(aWebProgress, aRequest, aState);
   }
   return NS_OK;
 }
 
 //*****************************************************************************
 // nsWebBrowser::nsIWebBrowserPersist
 //*****************************************************************************
 
--- a/toolkit/components/printing/content/printPreviewProgress.js
+++ b/toolkit/components/printing/content/printPreviewProgress.js
@@ -54,18 +54,17 @@ var progressListener = {
     if (docURLStr != docURL && dialog.title != null) {
       docURL = docURLStr;
       if (docTitle == "")
         dialog.title.value = docURLStr;
     }
   },
 
   onLocationChange(aWebProgress, aRequest, aLocation, aFlags) {},
-  onSecurityChange(aWebProgress, aRequest, aOldState, aState,
-                   aContentBlockingLogJSON) {},
+  onSecurityChange(aWebProgress, aRequest, state) {},
 
   onStatusChange(aWebProgress, aRequest, aStatus, aMessage) {
     if (aMessage)
       dialog.title.setAttribute("value", aMessage);
   },
 
   QueryInterface: ChromeUtils.generateQI(["nsIWebProgressListener",
                                           "nsISupportsWeakReference"]),
--- a/toolkit/components/printing/content/printProgress.js
+++ b/toolkit/components/printing/content/printProgress.js
@@ -139,18 +139,17 @@ var progressListener = {
       // we can ignore this notification
     },
 
     onStatusChange(aWebProgress, aRequest, aStatus, aMessage) {
       if (aMessage != "")
         dialog.title.setAttribute("value", aMessage);
     },
 
-    onSecurityChange(aWebProgress, aRequest, aOldState, aState,
-                     aContentBlockingLogJSON) {
+    onSecurityChange(aWebProgress, aRequest, state) {
       // we can ignore this notification
     },
 
     QueryInterface: ChromeUtils.generateQI(["nsIWebProgressListener",
                                             "nsISupportsWeakReference"]),
 };
 
 function getString( stringId ) {
--- a/toolkit/components/printingui/ipc/PrintProgressDialogChild.cpp
+++ b/toolkit/components/printingui/ipc/PrintProgressDialogChild.cpp
@@ -95,19 +95,17 @@ PrintProgressDialogChild::OnStatusChange
                                          const char16_t* aMessage)
 {
   return NS_OK;
 }
 
 NS_IMETHODIMP
 PrintProgressDialogChild::OnSecurityChange(nsIWebProgress* aProgress,
                                            nsIRequest* aRequest,
-                                           uint32_t aOldState,
-                                           uint32_t aState,
-                                           const nsAString& aContentBlockingLogJSON)
+                                           uint32_t aState)
 {
   return NS_OK;
 }
 
 // nsIPrintProgressParams
 
 NS_IMETHODIMP
 PrintProgressDialogChild::GetDocTitle(nsAString& aDocTitle)
--- a/toolkit/components/printingui/nsPrintProgress.cpp
+++ b/toolkit/components/printingui/nsPrintProgress.cpp
@@ -239,21 +239,17 @@ NS_IMETHODIMP nsPrintProgress::OnStatusC
     nsCOMPtr<nsIWebProgressListener> progressListener = m_listenerList.SafeObjectAt(i);
     if (progressListener)
       progressListener->OnStatusChange(aWebProgress, aRequest, aStatus, aMessage);
   }
 
   return NS_OK;
 }
 
-NS_IMETHODIMP nsPrintProgress::OnSecurityChange(nsIWebProgress *aWebProgress,
-                                                nsIRequest *aRequest,
-                                                uint32_t aOldState,
-                                                uint32_t aState,
-                                                const nsAString& aContentBlockingLogJSON)
+NS_IMETHODIMP nsPrintProgress::OnSecurityChange(nsIWebProgress *aWebProgress, nsIRequest *aRequest, uint32_t state)
 {
     return NS_OK;
 }
 
 nsresult nsPrintProgress::ReleaseListeners()
 {
   m_listenerList.Clear();
 
--- a/toolkit/components/printingui/nsPrintingPromptService.cpp
+++ b/toolkit/components/printingui/nsPrintingPromptService.cpp
@@ -223,21 +223,18 @@ nsPrintingPromptService::OnStatusChange(
   }
 #endif
   return NS_OK;
 }
 
 NS_IMETHODIMP
 nsPrintingPromptService::OnSecurityChange(nsIWebProgress* aWebProgress,
                                           nsIRequest* aRequest,
-                                          uint32_t aOldState,
-                                          uint32_t aState,
-                                          const nsAString& aContentBlockingLogJSON)
+                                          uint32_t state)
 {
 #if !defined(XP_MACOSX)
   if (mWebProgressListener) {
     return mWebProgressListener->OnSecurityChange(
-      aWebProgress, aRequest, aOldState, aState,
-      aContentBlockingLogJSON);
+      aWebProgress, aRequest, state);
   }
 #endif
   return NS_OK;
 }
--- a/toolkit/components/statusfilter/nsBrowserStatusFilter.cpp
+++ b/toolkit/components/statusfilter/nsBrowserStatusFilter.cpp
@@ -260,25 +260,22 @@ nsBrowserStatusFilter::OnStatusChange(ns
     mDelayedStatus = true;
 
     return NS_OK;
 }
 
 NS_IMETHODIMP
 nsBrowserStatusFilter::OnSecurityChange(nsIWebProgress *aWebProgress,
                                         nsIRequest *aRequest,
-                                        uint32_t aOldState,
-                                        uint32_t aState,
-                                        const nsAString& aContentBlockingLogJSON)
+                                        uint32_t aState)
 {
     if (!mListener)
         return NS_OK;
 
-    return mListener->OnSecurityChange(aWebProgress, aRequest, aOldState,
-                                       aState, aContentBlockingLogJSON);
+    return mListener->OnSecurityChange(aWebProgress, aRequest, aState);
 }
 
 //-----------------------------------------------------------------------------
 // nsBrowserStatusFilter::nsIWebProgressListener2
 //-----------------------------------------------------------------------------
 NS_IMETHODIMP
 nsBrowserStatusFilter::OnProgressChange64(nsIWebProgress *aWebProgress,
                                           nsIRequest *aRequest,
--- a/toolkit/components/url-classifier/tests/mochitest/test_threathit_report.html
+++ b/toolkit/components/url-classifier/tests/mochitest/test_threathit_report.html
@@ -189,18 +189,17 @@ function testOnWindow(aTestData) {
 
     (async function() {
       await new Promise(rs => whenDelayedStartupFinished(win, rs));
 
       let expected;
       let browser = win.gBrowser.selectedBrowser;
       let wp = win.gBrowser.contentWindow.docShell.QueryInterface(Ci.nsIWebProgress);
       let progressListener = {
-        onSecurityChange(aWebProgress, aRequest, aOldState, aState,
-                         aContentBlockingLogJSON) {
+        onSecurityChange(aWebProgress, aRequest, aState) {
           expected = aTestData.reportUrl;
         },
         QueryInterface: ChromeUtils.generateQI(["nsISupportsWeakReference"]),
       };
       wp.addProgressListener(progressListener, wp.NOTIFY_SECURITY);
 
       await BrowserTestUtils.loadURI(browser, aTestData.url);
       await BrowserTestUtils.waitForContentEvent(browser, "DOMContentLoaded");
--- a/toolkit/modules/RemoteSecurityUI.jsm
+++ b/toolkit/modules/RemoteSecurityUI.jsm
@@ -2,30 +2,24 @@
 // This Source Code Form is subject to the terms of the Mozilla Public
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
 var EXPORTED_SYMBOLS = ["RemoteSecurityUI"];
 
 function RemoteSecurityUI() {
     this._secInfo = null;
-    this._oldState = 0;
     this._state = 0;
-    this._contentBlockingLogJSON = "";
 }
 
 RemoteSecurityUI.prototype = {
   QueryInterface: ChromeUtils.generateQI([Ci.nsISecureBrowserUI]),
 
   // nsISecureBrowserUI
-  get oldState() { return this._oldState; },
   get state() { return this._state; },
-  get contentBlockingLogJSON() { return this._contentBlockingLogJSON; },
   get tooltipText() { return ""; },
   get secInfo() { return this._secInfo; },
 
-  _update(aSecInfo, aOldState, aState, aContentBlockingLogJSON) {
+  _update(aSecInfo, aState) {
     this._secInfo = aSecInfo;
-    this._oldState = aOldState;
     this._state = aState;
-    this._contentBlockingLogJSON = aContentBlockingLogJSON;
   },
 };
--- a/toolkit/modules/RemoteWebProgress.jsm
+++ b/toolkit/modules/RemoteWebProgress.jsm
@@ -104,27 +104,27 @@ RemoteWebProgressManager.prototype = {
     });
   },
 
   removeProgressListener(aListener) {
     this._progressListeners =
       this._progressListeners.filter(l => l.listener != aListener);
   },
 
-  _fixSecInfo(aSecInfo) {
+  _fixSecInfoAndState(aSecInfo, aState) {
     let deserialized = null;
     if (aSecInfo) {
       let helper = Cc["@mozilla.org/network/serialization-helper;1"]
                     .getService(Ci.nsISerializationHelper);
 
       deserialized = helper.deserializeObject(aSecInfo);
       deserialized.QueryInterface(Ci.nsITransportSecurityInfo);
     }
 
-    return deserialized;
+    return [deserialized, aState];
   },
 
   setCurrentURI(aURI) {
     // This function is simpler than nsDocShell::SetCurrentURI since
     // it doesn't have to deal with child docshells.
     let remoteWebNav = this._browser._remoteWebNavigationImpl;
     remoteWebNav._currentURI = aURI;
 
@@ -235,33 +235,29 @@ RemoteWebProgressManager.prototype = {
 
       this._callProgressListeners(
         Ci.nsIWebProgress.NOTIFY_LOCATION, "onLocationChange", webProgress,
         request, location, flags
       );
       break;
 
     case "Content:SecurityChange":
-      let secInfo = this._fixSecInfo(json.secInfo);
-      let oldState = json.oldState;
-      let state = json.state;
-      let contentBlockingLogJSON = json.contentBlockingLogJSON;
+      let [secInfo, state] = this._fixSecInfoAndState(json.secInfo, json.state);
 
       if (isTopLevel) {
         // Invoking this getter triggers the generation of the underlying object,
         // which we need to access with ._securityUI, because .securityUI returns
         // a wrapper that makes _update inaccessible.
         void this._browser.securityUI;
-        this._browser._securityUI._update(secInfo, oldState, state,
-                                          contentBlockingLogJSON);
+        this._browser._securityUI._update(secInfo, state);
       }
 
       this._callProgressListeners(
         Ci.nsIWebProgress.NOTIFY_SECURITY, "onSecurityChange", webProgress,
-        request, oldState, state, contentBlockingLogJSON
+        request, state
       );
       break;
 
     case "Content:StatusChange":
       this._callProgressListeners(
         Ci.nsIWebProgress.NOTIFY_STATUS, "onStatusChange", webProgress, request,
         json.status, json.message
       );
--- a/toolkit/modules/WebProgressChild.jsm
+++ b/toolkit/modules/WebProgressChild.jsm
@@ -208,25 +208,22 @@ class WebProgressChild {
     let secInfo = this.mm.docShell.securityUI.secInfo;
     if (secInfo) {
       return serializationHelper.serializeToString(secInfo);
     }
 
     return null;
   }
 
-  onSecurityChange(aWebProgress, aRequest, aOldState, aState,
-                   aContentBlockingLogJSON) {
+  onSecurityChange(aWebProgress, aRequest, aState) {
     let json = this._setupJSON(aWebProgress, aRequest);
     let objects = this._setupObjects(aWebProgress, aRequest);
 
-    json.oldState = aOldState;
     json.state = aState;
     json.secInfo = this.getSecInfoAsString();
-    json.contentBlockingLogJSON = aContentBlockingLogJSON;
 
     json.matchedList = null;
     if (aRequest && aRequest instanceof Ci.nsIClassifiedChannel) {
       json.matchedList = aRequest.matchedList;
     }
 
     this._send("Content:SecurityChange", json, objects);
   }
--- a/toolkit/mozapps/downloads/nsHelperAppDlg.js
+++ b/toolkit/mozapps/downloads/nsHelperAppDlg.js
@@ -65,18 +65,17 @@ nsUnknownContentTypeDialogProgressListen
 
 
   onStateChange(aWebProgress, aRequest, aStateFlags, aStatus) {
   },
 
   onLocationChange(aWebProgress, aRequest, aLocation, aFlags) {
   },
 
-  onSecurityChange(aWebProgress, aRequest, aOldState, aState,
-                   aContentBlockingLogJSON) {
+  onSecurityChange(aWebProgress, aRequest, state) {
   },
 
   onRefreshAttempted(aWebProgress, aURI, aDelay, aSameURI) {
     return true;
   },
 };
 
 // /////////////////////////////////////////////////////////////////////////////
--- a/toolkit/mozapps/extensions/content/extensions.js
+++ b/toolkit/mozapps/extensions/content/extensions.js
@@ -2130,18 +2130,17 @@ var gDiscoverView = {
         (!this.homepageURL.schemeIs("https") || aLocation.schemeIs("https")))
       return;
 
     // Canceling the request will send an error to onStateChange which will show
     // the error page
     aRequest.cancel(Cr.NS_BINDING_ABORTED);
   },
 
-  onSecurityChange(aWebProgress, aRequest, aOldState, aState,
-                   aContentBlockingLogJSON) {
+  onSecurityChange(aWebProgress, aRequest, aState) {
     // Don't care about security if the page is not https
     if (!this.homepageURL.schemeIs("https"))
       return;
 
     // If the request was secure then it is ok
     if (aState & Ci.nsIWebProgressListener.STATE_IS_SECURE)
       return;
 
--- a/uriloader/base/nsDocLoader.cpp
+++ b/uriloader/base/nsDocLoader.cpp
@@ -30,17 +30,16 @@
 
 #include "nsITransport.h"
 #include "nsISocketTransport.h"
 #include "nsIDocShell.h"
 #include "nsIDocument.h"
 #include "nsPresContext.h"
 #include "nsIAsyncVerifyRedirectCallback.h"
 
-using mozilla::dom::ContentBlockingLog;
 using mozilla::DebugOnly;
 using mozilla::LogLevel;
 
 //
 // Log module for nsIDocumentLoader logging...
 //
 // To enable logging (see mozilla/Logging.h for full details):
 //
@@ -1458,37 +1457,32 @@ NS_IMETHODIMP nsDocLoader::AsyncOnChanne
   return NS_OK;
 }
 
 /*
  * Implementation of nsISecurityEventSink method...
  */
 
 NS_IMETHODIMP nsDocLoader::OnSecurityChange(nsISupports * aContext,
-                                            uint32_t aOldState,
-                                            uint32_t aState,
-                                            ContentBlockingLog* aContentBlockingLog)
+                                            uint32_t aState)
 {
   //
   // Fire progress notifications out to any registered nsIWebProgressListeners.
   //
 
   nsCOMPtr<nsIRequest> request = do_QueryInterface(aContext);
   nsIWebProgress* webProgress = static_cast<nsIWebProgress*>(this);
-  nsAutoString contentBlockingLogJSON(
-    aContentBlockingLog ? aContentBlockingLog->Stringify() : EmptyString());
 
   NOTIFY_LISTENERS(nsIWebProgress::NOTIFY_SECURITY,
-    listener->OnSecurityChange(webProgress, request, aOldState, aState,
-                               contentBlockingLogJSON);
+    listener->OnSecurityChange(webProgress, request, aState);
   );
 
   // Pass the notification up to the parent...
   if (mParent) {
-    mParent->OnSecurityChange(aContext, aOldState, aState, aContentBlockingLog);
+    mParent->OnSecurityChange(aContext, aState);
   }
   return NS_OK;
 }
 
 /*
  * Implementation of nsISupportsPriority methods...
  *
  * The priority of the DocLoader _is_ the priority of its LoadGroup.
--- a/uriloader/base/nsIWebProgressListener.idl
+++ b/uriloader/base/nsIWebProgressListener.idl
@@ -469,37 +469,20 @@ interface nsIWebProgressListener : nsISu
    * security transitions (eg HTTP -> HTTPS, HTTPS -> HTTP, FOO -> HTTPS) and
    * after document load completion.  It might also be called if an error
    * occurs during network loading.
    *
    * @param aWebProgress
    *        The nsIWebProgress instance that fired the notification.
    * @param aRequest
    *        The nsIRequest that has new security state.
-   * @param aOldState
-   *        A value composed of the Security State Flags and the Security
-   *        Strength Flags listed above.  Any undefined bits are reserved for
-   *        future use.  This represents the security state before the change.
    * @param aState
    *        A value composed of the Security State Flags and the Security
    *        Strength Flags listed above.  Any undefined bits are reserved for
-   *        future use.  This represents the security state after the change.
-   * @param aContentBlockingLog
-   *        An optional JSON string representing a log of the content blocking
-   *        events happened so far.  This will be a JSON object containing keys
-   *        representing origins that content blocking has acted on, with values
-   *        being an array of items, each representing one action.  Each action
-   *        itself is an an array containing three elements, the first element
-   *        being a blocking code from one of the Security State Flags above, and
-   *        the second element being a boolean representing whether the origin
-   *        was blocked (if true) or unblocked (if false) in that category, and
-   *        the third element being the number of times that combination has been
-   *        repeated consecutively.
+   *        future use.
    *
    * NOTE: These notifications will only occur if a security package is
    * installed.
    */
   void onSecurityChange(in nsIWebProgress aWebProgress,
                         in nsIRequest aRequest,
-                        in unsigned long aOldState,
-                        in unsigned long aState,
-                        in AString aContentBlockingLogJSON);
+                        in unsigned long aState);
 };
--- a/uriloader/prefetch/nsOfflineCacheUpdateService.cpp
+++ b/uriloader/prefetch/nsOfflineCacheUpdateService.cpp
@@ -217,19 +217,17 @@ nsOfflineCachePendingUpdate::OnStatusCha
 {
     MOZ_ASSERT_UNREACHABLE("notification excluded in AddProgressListener(...)");
     return NS_OK;
 }
 
 NS_IMETHODIMP
 nsOfflineCachePendingUpdate::OnSecurityChange(nsIWebProgress *aWebProgress,
                                               nsIRequest *aRequest,
-                                              uint32_t aOldState,
-                                              uint32_t aState,
-                                              const nsAString& aContentBlockingLogJSON)
+                                              uint32_t state)
 {
     MOZ_ASSERT_UNREACHABLE("notification excluded in AddProgressListener(...)");
     return NS_OK;
 }
 
 //-----------------------------------------------------------------------------
 // nsOfflineCacheUpdateService::nsISupports
 //-----------------------------------------------------------------------------
--- a/uriloader/prefetch/nsPrefetchService.cpp
+++ b/uriloader/prefetch/nsPrefetchService.cpp
@@ -1023,19 +1023,17 @@ nsPrefetchService::OnStatusChange(nsIWeb
 {
     MOZ_ASSERT_UNREACHABLE("notification excluded in AddProgressListener(...)");
     return NS_OK;
 }
 
 NS_IMETHODIMP 
 nsPrefetchService::OnSecurityChange(nsIWebProgress *aWebProgress, 
                                     nsIRequest *aRequest, 
-                                    uint32_t aOldState,
-                                    uint32_t aState,
-                                    const nsAString& aContentBlockingLogJSON)
+                                    uint32_t state)
 {
     MOZ_ASSERT_UNREACHABLE("notification excluded in AddProgressListener(...)");
     return NS_OK;
 }
 
 //-----------------------------------------------------------------------------
 // nsPrefetchService::nsIObserver
 //-----------------------------------------------------------------------------
--- a/xpfe/appshell/nsChromeTreeOwner.cpp
+++ b/xpfe/appshell/nsChromeTreeOwner.cpp
@@ -494,19 +494,17 @@ nsChromeTreeOwner::OnStatusChange(nsIWeb
     return NS_OK;
 }
 
 
 
 NS_IMETHODIMP
 nsChromeTreeOwner::OnSecurityChange(nsIWebProgress *aWebProgress,
                                     nsIRequest *aRequest,
-                                    uint32_t aOldState,
-                                    uint32_t aState,
-                                    const nsAString& aContentBlockingLogJSON)
+                                    uint32_t state)
 {
     return NS_OK;
 }
 
 //*****************************************************************************
 // nsChromeTreeOwner: Helpers
 //*****************************************************************************
 
--- a/xpfe/appshell/nsWebShellWindow.cpp
+++ b/xpfe/appshell/nsWebShellWindow.cpp
@@ -671,19 +671,17 @@ nsWebShellWindow::OnStatusChange(nsIWebP
 {
   MOZ_ASSERT_UNREACHABLE("notification excluded in AddProgressListener(...)");
   return NS_OK;
 }
 
 NS_IMETHODIMP
 nsWebShellWindow::OnSecurityChange(nsIWebProgress *aWebProgress,
                                    nsIRequest *aRequest,
-                                   uint32_t aOldState,
-                                   uint32_t aState,
-                                   const nsAString& aContentBlockingLogJSON)
+                                   uint32_t state)
 {
   MOZ_ASSERT_UNREACHABLE("notification excluded in AddProgressListener(...)");
   return NS_OK;
 }
 
 
 /**
  * ExecuteCloseHandler - Run the close handler, if any.