Bug 1535525 - Rename TrackingDummyChannel to ClassifierDummyChannel, r=Ehsan
authorAndrea Marchesini <amarchesini@mozilla.com>
Fri, 15 Mar 2019 18:55:10 +0000
changeset 522322 8e01eb4f12c7701b7f7f389a9db3229606ba0179
parent 522321 12950622952644a4f7bff0e5b776d84dc81a1224
child 522323 fbb0b16293f0ecf46837f473e4b02235d13b3db5
push id10871
push usercbrindusan@mozilla.com
push dateMon, 18 Mar 2019 15:49:32 +0000
treeherdermozilla-beta@018abdd16060 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersEhsan
bugs1535525
milestone67.0a1
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
Bug 1535525 - Rename TrackingDummyChannel to ClassifierDummyChannel, r=Ehsan Differential Revision: https://phabricator.services.mozilla.com/D23616
dom/media/webrtc/PMediaTransport.ipdl
netwerk/ipc/NeckoChild.cpp
netwerk/ipc/NeckoChild.h
netwerk/ipc/NeckoParent.cpp
netwerk/ipc/NeckoParent.h
netwerk/ipc/PNecko.ipdl
netwerk/protocol/http/ClassifierDummyChannel.cpp
netwerk/protocol/http/ClassifierDummyChannel.h
netwerk/protocol/http/ClassifierDummyChannelChild.cpp
netwerk/protocol/http/ClassifierDummyChannelChild.h
netwerk/protocol/http/ClassifierDummyChannelParent.cpp
netwerk/protocol/http/ClassifierDummyChannelParent.h
netwerk/protocol/http/HttpBaseChannel.cpp
netwerk/protocol/http/HttpChannelChild.cpp
netwerk/protocol/http/PClassifierDummyChannel.ipdl
netwerk/protocol/http/PTrackingDummyChannel.ipdl
netwerk/protocol/http/TrackingDummyChannel.cpp
netwerk/protocol/http/TrackingDummyChannel.h
netwerk/protocol/http/TrackingDummyChannelChild.cpp
netwerk/protocol/http/TrackingDummyChannelChild.h
netwerk/protocol/http/TrackingDummyChannelParent.cpp
netwerk/protocol/http/TrackingDummyChannelParent.h
netwerk/protocol/http/moz.build
netwerk/url-classifier/UrlClassifierCommon.cpp
xpcom/io/InputStreamLengthHelper.h
--- a/dom/media/webrtc/PMediaTransport.ipdl
+++ b/dom/media/webrtc/PMediaTransport.ipdl
@@ -3,16 +3,17 @@
  * You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 include protocol PSocketProcessBridge;
 
 #ifdef MOZ_WEBRTC
 include PBrowserOrId;
 
 // ParamTraits stuff for generated code and other classes we don't want to change
+include "mozilla/net/NrIceStunAddrMessageUtils.h";
 include "mozilla/media/webrtc/WebrtcIPCTraits.h";
 using StringVector from "mozilla/media/webrtc/WebrtcIPCTraits.h";
 using CandidateInfo from "mozilla/media/webrtc/WebrtcIPCTraits.h";
 using DtlsDigestList from "mozilla/media/webrtc/WebrtcIPCTraits.h";
 using std::string from "ipc/IPCMessageUtils.h";
 using struct mozilla::dom::RTCStatsReportInternal from "mozilla/dom/RTCStatsReportBinding.h";
 using struct mozilla::dom::MovableRTCStatsReportInternal from "mozilla/media/webrtc/WebrtcGlobal.h";
 using WebrtcGlobalLog from "mozilla/media/webrtc/WebrtcGlobal.h";
--- a/netwerk/ipc/NeckoChild.cpp
+++ b/netwerk/ipc/NeckoChild.cpp
@@ -17,17 +17,17 @@
 #include "mozilla/net/WebSocketEventListenerChild.h"
 #include "mozilla/net/DNSRequestChild.h"
 #include "mozilla/net/ChannelDiverterChild.h"
 #include "mozilla/net/IPCTransportProvider.h"
 #include "mozilla/dom/network/TCPSocketChild.h"
 #include "mozilla/dom/network/TCPServerSocketChild.h"
 #include "mozilla/dom/network/UDPSocketChild.h"
 #include "mozilla/net/AltDataOutputStreamChild.h"
-#include "mozilla/net/TrackingDummyChannelChild.h"
+#include "mozilla/net/ClassifierDummyChannelChild.h"
 #include "mozilla/net/SocketProcessBridgeChild.h"
 #ifdef MOZ_WEBRTC
 #  include "mozilla/net/StunAddrsRequestChild.h"
 #  include "mozilla/net/WebrtcProxyChannelChild.h"
 #endif
 
 #include "SerializedLoadContext.h"
 #include "nsGlobalWindow.h"
@@ -404,22 +404,22 @@ mozilla::ipc::IPCResult NeckoChild::Recv
   nsCOMPtr<nsIObserverService> obsService = services::GetObserverService();
   if (obsService) {
     obsService->NotifyObservers(nullptr, NS_NETWORK_LINK_TOPIC,
                                 NS_ConvertUTF8toUTF16(type).get());
   }
   return IPC_OK();
 }
 
-PTrackingDummyChannelChild* NeckoChild::AllocPTrackingDummyChannelChild(
+PClassifierDummyChannelChild* NeckoChild::AllocPClassifierDummyChannelChild(
     nsIURI* aURI, nsIURI* aTopWindowURI, const nsresult& aTopWindowURIResult,
     const Maybe<LoadInfoArgs>& aLoadInfo) {
-  return new TrackingDummyChannelChild();
+  return new ClassifierDummyChannelChild();
 }
 
-bool NeckoChild::DeallocPTrackingDummyChannelChild(
-    PTrackingDummyChannelChild* aActor) {
-  delete static_cast<TrackingDummyChannelChild*>(aActor);
+bool NeckoChild::DeallocPClassifierDummyChannelChild(
+    PClassifierDummyChannelChild* aActor) {
+  delete static_cast<ClassifierDummyChannelChild*>(aActor);
   return true;
 }
 
 }  // namespace net
 }  // namespace mozilla
--- a/netwerk/ipc/NeckoChild.h
+++ b/netwerk/ipc/NeckoChild.h
@@ -88,21 +88,22 @@ class NeckoChild : public PNeckoChild {
   mozilla::ipc::IPCResult RecvPredOnPredictPrefetch(
       const URIParams& aURI, const uint32_t& aHttpStatus);
   mozilla::ipc::IPCResult RecvPredOnPredictPreconnect(const URIParams& aURI);
   mozilla::ipc::IPCResult RecvPredOnPredictDNS(const URIParams& aURI);
 
   mozilla::ipc::IPCResult RecvSpeculativeConnectRequest();
   mozilla::ipc::IPCResult RecvNetworkChangeNotification(nsCString const& type);
 
-  PTrackingDummyChannelChild* AllocPTrackingDummyChannelChild(
+  PClassifierDummyChannelChild* AllocPClassifierDummyChannelChild(
       nsIURI* aURI, nsIURI* aTopWindowURI, const nsresult& aTopWindowURIResult,
       const Maybe<LoadInfoArgs>& aLoadInfo);
 
-  bool DeallocPTrackingDummyChannelChild(PTrackingDummyChannelChild* aChannel);
+  bool DeallocPClassifierDummyChannelChild(
+      PClassifierDummyChannelChild* aChannel);
 };
 
 /**
  * Reference to the PNecko Child protocol.
  * Null if this is not a content process.
  */
 extern PNeckoChild* gNeckoChild;
 
--- a/netwerk/ipc/NeckoParent.cpp
+++ b/netwerk/ipc/NeckoParent.cpp
@@ -19,19 +19,19 @@
 #include "mozilla/net/WebSocketEventListenerParent.h"
 #include "mozilla/net/DataChannelParent.h"
 #include "mozilla/net/SimpleChannelParent.h"
 #include "mozilla/net/AltDataOutputStreamParent.h"
 #include "mozilla/Unused.h"
 #include "mozilla/net/FileChannelParent.h"
 #include "mozilla/net/DNSRequestParent.h"
 #include "mozilla/net/ChannelDiverterParent.h"
+#include "mozilla/net/ClassifierDummyChannelParent.h"
 #include "mozilla/net/IPCTransportProvider.h"
 #include "mozilla/net/RequestContextService.h"
-#include "mozilla/net/TrackingDummyChannelParent.h"
 #include "mozilla/net/SocketProcessParent.h"
 #include "mozilla/net/PSocketProcessBridgeParent.h"
 #ifdef MOZ_WEBRTC
 #  include "mozilla/net/StunAddrsRequestParent.h"
 #  include "mozilla/net/WebrtcProxyChannelParent.h"
 #endif
 #include "mozilla/dom/ChromeUtils.h"
 #include "mozilla/dom/ContentParent.h"
@@ -900,47 +900,47 @@ mozilla::ipc::IPCResult NeckoParent::Rec
   if (result.isErr()) {
     FileDescriptor invalidFD;
     aResolve(invalidFD);
   }
 
   return IPC_OK();
 }
 
-PTrackingDummyChannelParent* NeckoParent::AllocPTrackingDummyChannelParent(
+PClassifierDummyChannelParent* NeckoParent::AllocPClassifierDummyChannelParent(
     nsIURI* aURI, nsIURI* aTopWindowURI, const nsresult& aTopWindowURIResult,
     const Maybe<LoadInfoArgs>& aLoadInfo) {
-  RefPtr<TrackingDummyChannelParent> c = new TrackingDummyChannelParent();
+  RefPtr<ClassifierDummyChannelParent> c = new ClassifierDummyChannelParent();
   return c.forget().take();
 }
 
-mozilla::ipc::IPCResult NeckoParent::RecvPTrackingDummyChannelConstructor(
-    PTrackingDummyChannelParent* aActor, nsIURI* aURI, nsIURI* aTopWindowURI,
+mozilla::ipc::IPCResult NeckoParent::RecvPClassifierDummyChannelConstructor(
+    PClassifierDummyChannelParent* aActor, nsIURI* aURI, nsIURI* aTopWindowURI,
     const nsresult& aTopWindowURIResult, const Maybe<LoadInfoArgs>& aLoadInfo) {
-  TrackingDummyChannelParent* p =
-      static_cast<TrackingDummyChannelParent*>(aActor);
+  ClassifierDummyChannelParent* p =
+      static_cast<ClassifierDummyChannelParent*>(aActor);
 
   if (NS_WARN_IF(!aURI)) {
     return IPC_FAIL_NO_REASON(this);
   }
 
   nsCOMPtr<nsILoadInfo> loadInfo;
   nsresult rv = LoadInfoArgsToLoadInfo(aLoadInfo, getter_AddRefs(loadInfo));
   if (NS_WARN_IF(NS_FAILED(rv)) || !loadInfo) {
     return IPC_FAIL_NO_REASON(this);
   }
 
   p->Init(aURI, aTopWindowURI, aTopWindowURIResult, loadInfo);
   return IPC_OK();
 }
 
-bool NeckoParent::DeallocPTrackingDummyChannelParent(
-    PTrackingDummyChannelParent* aActor) {
-  RefPtr<TrackingDummyChannelParent> c =
-      dont_AddRef(static_cast<TrackingDummyChannelParent*>(aActor));
+bool NeckoParent::DeallocPClassifierDummyChannelParent(
+    PClassifierDummyChannelParent* aActor) {
+  RefPtr<ClassifierDummyChannelParent> c =
+      dont_AddRef(static_cast<ClassifierDummyChannelParent*>(aActor));
   MOZ_ASSERT(c);
   return true;
 }
 
 mozilla::ipc::IPCResult NeckoParent::RecvInitSocketProcessBridge(
     InitSocketProcessBridgeResolver&& aResolver) {
   MOZ_ASSERT(NS_IsMainThread());
 
--- a/netwerk/ipc/NeckoParent.h
+++ b/netwerk/ipc/NeckoParent.h
@@ -218,25 +218,26 @@ class NeckoParent : public PNeckoParent 
 
   /* WebExtensions */
   mozilla::ipc::IPCResult RecvGetExtensionStream(
       const URIParams& aURI, GetExtensionStreamResolver&& aResolve);
 
   mozilla::ipc::IPCResult RecvGetExtensionFD(const URIParams& aURI,
                                              GetExtensionFDResolver&& aResolve);
 
-  PTrackingDummyChannelParent* AllocPTrackingDummyChannelParent(
+  PClassifierDummyChannelParent* AllocPClassifierDummyChannelParent(
       nsIURI* aURI, nsIURI* aTopWindowURI, const nsresult& aTopWindowURIResult,
       const Maybe<LoadInfoArgs>& aLoadInfo);
 
-  bool DeallocPTrackingDummyChannelParent(PTrackingDummyChannelParent* aChild);
+  bool DeallocPClassifierDummyChannelParent(
+      PClassifierDummyChannelParent* aChild);
 
-  virtual mozilla::ipc::IPCResult RecvPTrackingDummyChannelConstructor(
-      PTrackingDummyChannelParent* aActor, nsIURI* aURI, nsIURI* aTopWindowURI,
-      const nsresult& aTopWindowURIResult,
+  virtual mozilla::ipc::IPCResult RecvPClassifierDummyChannelConstructor(
+      PClassifierDummyChannelParent* aActor, nsIURI* aURI,
+      nsIURI* aTopWindowURI, const nsresult& aTopWindowURIResult,
       const Maybe<LoadInfoArgs>& aLoadInfo) override;
 
   mozilla::ipc::IPCResult RecvInitSocketProcessBridge(
       InitSocketProcessBridgeResolver&& aResolver);
 };
 
 }  // namespace net
 }  // namespace mozilla
--- a/netwerk/ipc/PNecko.ipdl
+++ b/netwerk/ipc/PNecko.ipdl
@@ -20,17 +20,17 @@ include protocol PChannelDiverter;
 include protocol PFileDescriptorSet;
 include protocol PDataChannel;
 include protocol PSimpleChannel;
 include protocol PTransportProvider;
 include protocol PChildToParentStream; //FIXME: bug #792908
 include protocol PParentToChildStream; //FIXME: bug #792908
 include protocol PStunAddrsRequest;
 include protocol PFileChannel;
-include protocol PTrackingDummyChannel;
+include protocol PClassifierDummyChannel;
 include protocol PWebrtcProxyChannel;
 include protocol PSocketProcessBridge;
 
 include IPCStream;
 include URIParams;
 include NeckoChannelParams;
 include PBrowserOrId;
 include protocol PAltDataOutputStream;
@@ -59,17 +59,17 @@ nested(upto inside_cpow) sync protocol P
   manages PDNSRequest;
   manages PDataChannel;
   manages PSimpleChannel;
   manages PFileChannel;
   manages PChannelDiverter;
   manages PTransportProvider;
   manages PAltDataOutputStream;
   manages PStunAddrsRequest;
-  manages PTrackingDummyChannel;
+  manages PClassifierDummyChannel;
   manages PWebrtcProxyChannel;
 
 parent:
   async __delete__();
 
   nested(inside_cpow) async PCookieService();
   async PHttpChannel(PBrowserOrId browser,
                      SerializedLoadContext loadContext,
@@ -107,19 +107,19 @@ parent:
    * the parent and the child when we're redirecting to a data: URI.
    */
   async PDataChannel(uint32_t channelId);
   async PSimpleChannel(uint32_t channelId);
   async PFileChannel(uint32_t channelId);
 
   async PChannelDiverter(ChannelDiverterArgs channel);
 
-  async PTrackingDummyChannel(nsIURI uri, nsIURI aTopWindowURI,
-                              nsresult aTopWindowURIResult,
-                              LoadInfoArgs? loadInfo);
+  async PClassifierDummyChannel(nsIURI uri, nsIURI aTopWindowURI,
+                                nsresult aTopWindowURIResult,
+                                LoadInfoArgs? loadInfo);
 
   /**
    * These are called from the child with the results of the auth prompt.
    * callbackId is the id that was passed in PBrowser::AsyncAuthPrompt,
    * corresponding to an nsIAuthPromptCallback
    */
   async OnAuthAvailable(uint64_t callbackId, nsString user,
                         nsString password, nsString domain);
rename from netwerk/protocol/http/TrackingDummyChannel.cpp
rename to netwerk/protocol/http/ClassifierDummyChannel.cpp
--- a/netwerk/protocol/http/TrackingDummyChannel.cpp
+++ b/netwerk/protocol/http/ClassifierDummyChannel.cpp
@@ -1,30 +1,32 @@
 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* vim: set sw=2 ts=8 et 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/. */
 
-#include "TrackingDummyChannel.h"
+#include "ClassifierDummyChannel.h"
 
 #include "mozilla/AntiTrackingCommon.h"
-#include "mozilla/net/TrackingDummyChannelChild.h"
+#include "mozilla/net/ClassifierDummyChannelChild.h"
 #include "mozilla/dom/ContentChild.h"
 #include "mozilla/Preferences.h"
+#include "nsContentSecurityManager.h"
 #include "nsIChannel.h"
 #include "nsIURI.h"
 #include "nsProxyRelease.h"
+#include "nsQueryObject.h"
 
 namespace mozilla {
 namespace net {
 
-/* static */ TrackingDummyChannel::StorageAllowedState
-TrackingDummyChannel::StorageAllowed(
+/* static */ ClassifierDummyChannel::StorageAllowedState
+ClassifierDummyChannel::StorageAllowed(
     nsIChannel* aChannel, const std::function<void(bool)>& aCallback) {
   MOZ_ASSERT(!XRE_IsParentProcess());
 
   nsCOMPtr<nsIHttpChannel> httpChannel = do_QueryInterface(aChannel);
   if (!httpChannel) {
     // Any non-http channel is allowed.
     return eStorageGranted;
   }
@@ -38,582 +40,588 @@ TrackingDummyChannel::StorageAllowed(
     //   considered trusted.
     return eStorageGranted;
   }
 
   nsCOMPtr<nsIURI> uri;
   aChannel->GetURI(getter_AddRefs(uri));
 
   if (StaticPrefs::privacy_trackingprotection_annotate_channels()) {
-    ContentChild* cc = static_cast<ContentChild*>(gNeckoChild->Manager());
+    dom::ContentChild* cc = static_cast<dom::ContentChild*>(gNeckoChild->Manager());
     if (cc->IsShuttingDown()) {
       return eStorageDenied;
     }
 
-    if (!TrackingDummyChannelChild::Create(httpChannel, uri, aCallback)) {
+    if (!ClassifierDummyChannelChild::Create(httpChannel, uri, aCallback)) {
       return eStorageDenied;
     }
 
     return eAsyncNeeded;
   }
 
   if (AntiTrackingCommon::IsFirstPartyStorageAccessGrantedFor(httpChannel, uri,
                                                               nullptr)) {
     return eStorageGranted;
   }
 
   return eStorageDenied;
 }
 
-NS_IMPL_ADDREF(TrackingDummyChannel)
-NS_IMPL_RELEASE(TrackingDummyChannel)
+NS_IMPL_ADDREF(ClassifierDummyChannel)
+NS_IMPL_RELEASE(ClassifierDummyChannel)
 
-NS_INTERFACE_MAP_BEGIN(TrackingDummyChannel)
+NS_INTERFACE_MAP_BEGIN(ClassifierDummyChannel)
   NS_INTERFACE_MAP_ENTRY(nsIRequest)
   NS_INTERFACE_MAP_ENTRY(nsIChannel)
   NS_INTERFACE_MAP_ENTRY(nsIHttpChannelInternal)
-  NS_INTERFACE_MAP_ENTRY_CONCRETE(TrackingDummyChannel)
+  NS_INTERFACE_MAP_ENTRY_CONCRETE(ClassifierDummyChannel)
 NS_INTERFACE_MAP_END
 
-TrackingDummyChannel::TrackingDummyChannel(nsIURI* aURI, nsIURI* aTopWindowURI,
-                                           nsresult aTopWindowURIResult,
-                                           nsILoadInfo* aLoadInfo)
+ClassifierDummyChannel::ClassifierDummyChannel(nsIURI* aURI,
+                                               nsIURI* aTopWindowURI,
+                                               nsresult aTopWindowURIResult,
+                                               nsILoadInfo* aLoadInfo)
     : mTopWindowURI(aTopWindowURI),
       mTopWindowURIResult(aTopWindowURIResult),
       mClassificationFlags(0) {
   MOZ_ASSERT(XRE_IsParentProcess());
 
   SetOriginalURI(aURI);
   SetLoadInfo(aLoadInfo);
 }
 
-TrackingDummyChannel::~TrackingDummyChannel() {
-  NS_ReleaseOnMainThreadSystemGroup("TrackingDummyChannel::mLoadInfo",
+ClassifierDummyChannel::~ClassifierDummyChannel() {
+  NS_ReleaseOnMainThreadSystemGroup("ClassifierDummyChannel::mLoadInfo",
                                     mLoadInfo.forget());
-  NS_ReleaseOnMainThreadSystemGroup("TrackingDummyChannel::mURI",
+  NS_ReleaseOnMainThreadSystemGroup("ClassifierDummyChannel::mURI",
                                     mURI.forget());
-  NS_ReleaseOnMainThreadSystemGroup("TrackingDummyChannel::mTopWindowURI",
+  NS_ReleaseOnMainThreadSystemGroup("ClassifierDummyChannel::mTopWindowURI",
                                     mTopWindowURI.forget());
 }
 
-uint32_t TrackingDummyChannel::ClassificationFlags() const {
+uint32_t ClassifierDummyChannel::ClassificationFlags() const {
   return mClassificationFlags;
 }
 
-void TrackingDummyChannel::AddClassificationFlags(
+void ClassifierDummyChannel::AddClassificationFlags(
     uint32_t aClassificationFlags) {
   mClassificationFlags |= aClassificationFlags;
 }
 
 //-----------------------------------------------------------------------------
-// TrackingDummyChannel::nsIChannel
+// ClassifierDummyChannel::nsIChannel
 //-----------------------------------------------------------------------------
 
 NS_IMETHODIMP
-TrackingDummyChannel::GetOriginalURI(nsIURI** aOriginalURI) {
+ClassifierDummyChannel::GetOriginalURI(nsIURI** aOriginalURI) {
   NS_IF_ADDREF(*aOriginalURI = mURI);
   return NS_OK;
 }
 
 NS_IMETHODIMP
-TrackingDummyChannel::SetOriginalURI(nsIURI* aOriginalURI) {
+ClassifierDummyChannel::SetOriginalURI(nsIURI* aOriginalURI) {
   mURI = aOriginalURI;
   return NS_OK;
 }
 
 NS_IMETHODIMP
-TrackingDummyChannel::GetURI(nsIURI** aURI) {
+ClassifierDummyChannel::GetURI(nsIURI** aURI) {
   NS_IF_ADDREF(*aURI = mURI);
   return NS_OK;
 }
 
 NS_IMETHODIMP
-TrackingDummyChannel::GetOwner(nsISupports** aOwner) {
+ClassifierDummyChannel::GetOwner(nsISupports** aOwner) {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-TrackingDummyChannel::SetOwner(nsISupports* aOwner) {
+ClassifierDummyChannel::SetOwner(nsISupports* aOwner) {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-TrackingDummyChannel::GetNotificationCallbacks(
+ClassifierDummyChannel::GetNotificationCallbacks(
     nsIInterfaceRequestor** aNotificationCallbacks) {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-TrackingDummyChannel::SetNotificationCallbacks(
+ClassifierDummyChannel::SetNotificationCallbacks(
     nsIInterfaceRequestor* aNotificationCallbacks) {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-TrackingDummyChannel::GetSecurityInfo(nsISupports** aSecurityInfo) {
+ClassifierDummyChannel::GetSecurityInfo(nsISupports** aSecurityInfo) {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-TrackingDummyChannel::GetContentType(nsACString& aContentType) {
+ClassifierDummyChannel::GetContentType(nsACString& aContentType) {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-TrackingDummyChannel::SetContentType(const nsACString& aContentType) {
+ClassifierDummyChannel::SetContentType(const nsACString& aContentType) {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-TrackingDummyChannel::GetContentCharset(nsACString& aContentCharset) {
+ClassifierDummyChannel::GetContentCharset(nsACString& aContentCharset) {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-TrackingDummyChannel::SetContentCharset(const nsACString& aContentCharset) {
+ClassifierDummyChannel::SetContentCharset(const nsACString& aContentCharset) {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-TrackingDummyChannel::GetContentLength(int64_t* aContentLength) {
+ClassifierDummyChannel::GetContentLength(int64_t* aContentLength) {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-TrackingDummyChannel::SetContentLength(int64_t aContentLength) {
+ClassifierDummyChannel::SetContentLength(int64_t aContentLength) {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-TrackingDummyChannel::Open(nsIInputStream** aStream) {
+ClassifierDummyChannel::Open(nsIInputStream** aStream) {
   nsCOMPtr<nsIStreamListener> listener;
   nsresult rv =
       nsContentSecurityManager::doContentSecurityCheck(this, listener);
   NS_ENSURE_SUCCESS(rv, rv);
 
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-TrackingDummyChannel::AsyncOpen(nsIStreamListener* aListener) {
+ClassifierDummyChannel::AsyncOpen(nsIStreamListener* aListener) {
   nsCOMPtr<nsIStreamListener> listener = aListener;
   nsresult rv =
       nsContentSecurityManager::doContentSecurityCheck(this, listener);
   NS_ENSURE_SUCCESS(rv, rv);
   return AsyncOpen(listener);
 }
 
 NS_IMETHODIMP
-TrackingDummyChannel::GetContentDisposition(uint32_t* aContentDisposition) {
+ClassifierDummyChannel::GetContentDisposition(uint32_t* aContentDisposition) {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-TrackingDummyChannel::SetContentDisposition(uint32_t aContentDisposition) {
+ClassifierDummyChannel::SetContentDisposition(uint32_t aContentDisposition) {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-TrackingDummyChannel::GetContentDispositionFilename(
+ClassifierDummyChannel::GetContentDispositionFilename(
     nsAString& aContentDispositionFilename) {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-TrackingDummyChannel::SetContentDispositionFilename(
+ClassifierDummyChannel::SetContentDispositionFilename(
     const nsAString& aContentDispositionFilename) {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-TrackingDummyChannel::GetContentDispositionHeader(
+ClassifierDummyChannel::GetContentDispositionHeader(
     nsACString& aContentDispositionHeader) {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-TrackingDummyChannel::GetLoadInfo(nsILoadInfo** aLoadInfo) {
+ClassifierDummyChannel::GetLoadInfo(nsILoadInfo** aLoadInfo) {
   NS_IF_ADDREF(*aLoadInfo = mLoadInfo);
   return NS_OK;
 }
 
 NS_IMETHODIMP
-TrackingDummyChannel::SetLoadInfo(nsILoadInfo* aLoadInfo) {
+ClassifierDummyChannel::SetLoadInfo(nsILoadInfo* aLoadInfo) {
   MOZ_RELEASE_ASSERT(aLoadInfo, "loadinfo can't be null");
   mLoadInfo = aLoadInfo;
   return NS_OK;
 }
 
 //-----------------------------------------------------------------------------
-// TrackingDummyChannel::nsIRequest
+// ClassifierDummyChannel::nsIRequest
 //-----------------------------------------------------------------------------
 
 NS_IMETHODIMP
-TrackingDummyChannel::GetName(nsACString& aName) {
+ClassifierDummyChannel::GetName(nsACString& aName) {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-TrackingDummyChannel::IsPending(bool* aRetval) {
+ClassifierDummyChannel::IsPending(bool* aRetval) {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-TrackingDummyChannel::GetStatus(nsresult* aStatus) {
+ClassifierDummyChannel::GetStatus(nsresult* aStatus) {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-TrackingDummyChannel::Cancel(nsresult aStatus) {
+ClassifierDummyChannel::Cancel(nsresult aStatus) {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-TrackingDummyChannel::Suspend() { return NS_ERROR_NOT_IMPLEMENTED; }
+ClassifierDummyChannel::Suspend() { return NS_ERROR_NOT_IMPLEMENTED; }
 
 NS_IMETHODIMP
-TrackingDummyChannel::Resume() { return NS_ERROR_NOT_IMPLEMENTED; }
+ClassifierDummyChannel::Resume() { return NS_ERROR_NOT_IMPLEMENTED; }
 
 NS_IMETHODIMP
-TrackingDummyChannel::GetLoadGroup(nsILoadGroup** aLoadGroup) {
+ClassifierDummyChannel::GetLoadGroup(nsILoadGroup** aLoadGroup) {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-TrackingDummyChannel::SetLoadGroup(nsILoadGroup* aLoadGroup) {
+ClassifierDummyChannel::SetLoadGroup(nsILoadGroup* aLoadGroup) {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-TrackingDummyChannel::GetLoadFlags(nsLoadFlags* aLoadFlags) {
+ClassifierDummyChannel::GetLoadFlags(nsLoadFlags* aLoadFlags) {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-TrackingDummyChannel::SetLoadFlags(nsLoadFlags aLoadFlags) {
+ClassifierDummyChannel::SetLoadFlags(nsLoadFlags aLoadFlags) {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-TrackingDummyChannel::GetIsDocument(bool* aIsDocument) {
+ClassifierDummyChannel::GetIsDocument(bool* aIsDocument) {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 //-----------------------------------------------------------------------------
-// TrackingDummyChannel::nsIHttpChannelInternal
+// ClassifierDummyChannel::nsIHttpChannelInternal
 //-----------------------------------------------------------------------------
 
 NS_IMETHODIMP
-TrackingDummyChannel::GetDocumentURI(nsIURI** aDocumentURI) {
+ClassifierDummyChannel::GetDocumentURI(nsIURI** aDocumentURI) {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-TrackingDummyChannel::SetDocumentURI(nsIURI* aDocumentURI) {
+ClassifierDummyChannel::SetDocumentURI(nsIURI* aDocumentURI) {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-TrackingDummyChannel::GetRequestVersion(uint32_t* aMajor, uint32_t* aMinor) {
+ClassifierDummyChannel::GetRequestVersion(uint32_t* aMajor, uint32_t* aMinor) {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-TrackingDummyChannel::GetResponseVersion(uint32_t* aMajor, uint32_t* aMinor) {
+ClassifierDummyChannel::GetResponseVersion(uint32_t* aMajor, uint32_t* aMinor) {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-TrackingDummyChannel::TakeAllSecurityMessages(
+ClassifierDummyChannel::TakeAllSecurityMessages(
     nsCOMArray<nsISecurityConsoleMessage>& aMessages) {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-TrackingDummyChannel::SetCookie(const char* aCookieHeader) {
+ClassifierDummyChannel::SetCookie(const char* aCookieHeader) {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-TrackingDummyChannel::SetupFallbackChannel(const char* aFallbackKey) {
+ClassifierDummyChannel::SetupFallbackChannel(const char* aFallbackKey) {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-TrackingDummyChannel::GetThirdPartyFlags(uint32_t* aThirdPartyFlags) {
+ClassifierDummyChannel::GetThirdPartyFlags(uint32_t* aThirdPartyFlags) {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-TrackingDummyChannel::SetThirdPartyFlags(uint32_t aThirdPartyFlags) {
+ClassifierDummyChannel::SetThirdPartyFlags(uint32_t aThirdPartyFlags) {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-TrackingDummyChannel::GetForceAllowThirdPartyCookie(
+ClassifierDummyChannel::GetForceAllowThirdPartyCookie(
     bool* aForceAllowThirdPartyCookie) {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-TrackingDummyChannel::SetForceAllowThirdPartyCookie(
+ClassifierDummyChannel::SetForceAllowThirdPartyCookie(
     bool aForceAllowThirdPartyCookie) {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-TrackingDummyChannel::GetCanceled(bool* aCanceled) {
+ClassifierDummyChannel::GetCanceled(bool* aCanceled) {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-TrackingDummyChannel::GetChannelIsForDownload(bool* aChannlIsForDownload) {
+ClassifierDummyChannel::GetChannelIsForDownload(bool* aChannlIsForDownload) {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-TrackingDummyChannel::SetChannelIsForDownload(bool aChannlIsForDownload) {
+ClassifierDummyChannel::SetChannelIsForDownload(bool aChannlIsForDownload) {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-TrackingDummyChannel::GetLocalAddress(nsACString& aLocalAddress) {
+ClassifierDummyChannel::GetLocalAddress(nsACString& aLocalAddress) {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-TrackingDummyChannel::GetLocalPort(int32_t* aLocalPort) {
+ClassifierDummyChannel::GetLocalPort(int32_t* aLocalPort) {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-TrackingDummyChannel::GetRemoteAddress(nsACString& aRemoteAddress) {
+ClassifierDummyChannel::GetRemoteAddress(nsACString& aRemoteAddress) {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-TrackingDummyChannel::GetRemotePort(int32_t* aRemotePort) {
+ClassifierDummyChannel::GetRemotePort(int32_t* aRemotePort) {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-TrackingDummyChannel::SetCacheKeysRedirectChain(
+ClassifierDummyChannel::SetCacheKeysRedirectChain(
     nsTArray<nsCString>* aCacheKeys) {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-TrackingDummyChannel::HTTPUpgrade(const nsACString& aProtocolName,
-                                  nsIHttpUpgradeListener* aListener) {
+ClassifierDummyChannel::HTTPUpgrade(const nsACString& aProtocolName,
+                                    nsIHttpUpgradeListener* aListener) {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-TrackingDummyChannel::GetOnlyConnect(bool* aOnlyConnect) {
+ClassifierDummyChannel::GetOnlyConnect(bool* aOnlyConnect) {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-TrackingDummyChannel::SetConnectOnly() { return NS_ERROR_NOT_IMPLEMENTED; }
+ClassifierDummyChannel::SetConnectOnly() { return NS_ERROR_NOT_IMPLEMENTED; }
 
 NS_IMETHODIMP
-TrackingDummyChannel::GetAllowSpdy(bool* aAllowSpdy) {
+ClassifierDummyChannel::GetAllowSpdy(bool* aAllowSpdy) {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-TrackingDummyChannel::SetAllowSpdy(bool aAllowSpdy) {
+ClassifierDummyChannel::SetAllowSpdy(bool aAllowSpdy) {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-TrackingDummyChannel::GetResponseTimeoutEnabled(bool* aResponseTimeoutEnabled) {
+ClassifierDummyChannel::GetResponseTimeoutEnabled(
+    bool* aResponseTimeoutEnabled) {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-TrackingDummyChannel::SetResponseTimeoutEnabled(bool aResponseTimeoutEnabled) {
+ClassifierDummyChannel::SetResponseTimeoutEnabled(
+    bool aResponseTimeoutEnabled) {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-TrackingDummyChannel::GetInitialRwin(uint32_t* aInitialRwin) {
+ClassifierDummyChannel::GetInitialRwin(uint32_t* aInitialRwin) {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-TrackingDummyChannel::SetInitialRwin(uint32_t aInitialRwin) {
+ClassifierDummyChannel::SetInitialRwin(uint32_t aInitialRwin) {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-TrackingDummyChannel::GetApiRedirectToURI(nsIURI** aApiRedirectToURI) {
+ClassifierDummyChannel::GetApiRedirectToURI(nsIURI** aApiRedirectToURI) {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-TrackingDummyChannel::GetAllowAltSvc(bool* aAllowAltSvc) {
+ClassifierDummyChannel::GetAllowAltSvc(bool* aAllowAltSvc) {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-TrackingDummyChannel::SetAllowAltSvc(bool aAllowAltSvc) {
+ClassifierDummyChannel::SetAllowAltSvc(bool aAllowAltSvc) {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-TrackingDummyChannel::GetBeConservative(bool* aBeConservative) {
+ClassifierDummyChannel::GetBeConservative(bool* aBeConservative) {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-TrackingDummyChannel::SetBeConservative(bool aBeConservative) {
+ClassifierDummyChannel::SetBeConservative(bool aBeConservative) {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-TrackingDummyChannel::GetTrr(bool* aTrr) { return NS_ERROR_NOT_IMPLEMENTED; }
+ClassifierDummyChannel::GetTrr(bool* aTrr) { return NS_ERROR_NOT_IMPLEMENTED; }
 
 NS_IMETHODIMP
-TrackingDummyChannel::SetTrr(bool aTrr) { return NS_ERROR_NOT_IMPLEMENTED; }
+ClassifierDummyChannel::SetTrr(bool aTrr) { return NS_ERROR_NOT_IMPLEMENTED; }
 
 NS_IMETHODIMP
-TrackingDummyChannel::GetTlsFlags(uint32_t* aTlsFlags) {
+ClassifierDummyChannel::GetTlsFlags(uint32_t* aTlsFlags) {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-TrackingDummyChannel::SetTlsFlags(uint32_t aTlsFlags) {
+ClassifierDummyChannel::SetTlsFlags(uint32_t aTlsFlags) {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-TrackingDummyChannel::GetLastModifiedTime(PRTime* aLastModifiedTime) {
+ClassifierDummyChannel::GetLastModifiedTime(PRTime* aLastModifiedTime) {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-TrackingDummyChannel::GetCorsIncludeCredentials(bool* aCorsIncludeCredentials) {
+ClassifierDummyChannel::GetCorsIncludeCredentials(
+    bool* aCorsIncludeCredentials) {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-TrackingDummyChannel::SetCorsIncludeCredentials(bool aCorsIncludeCredentials) {
+ClassifierDummyChannel::SetCorsIncludeCredentials(
+    bool aCorsIncludeCredentials) {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-TrackingDummyChannel::GetCorsMode(uint32_t* aCorsMode) {
+ClassifierDummyChannel::GetCorsMode(uint32_t* aCorsMode) {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-TrackingDummyChannel::SetCorsMode(uint32_t aCorsMode) {
+ClassifierDummyChannel::SetCorsMode(uint32_t aCorsMode) {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-TrackingDummyChannel::GetRedirectMode(uint32_t* aRedirectMode) {
+ClassifierDummyChannel::GetRedirectMode(uint32_t* aRedirectMode) {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-TrackingDummyChannel::SetRedirectMode(uint32_t aRedirectMode) {
+ClassifierDummyChannel::SetRedirectMode(uint32_t aRedirectMode) {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-TrackingDummyChannel::GetFetchCacheMode(uint32_t* aFetchCacheMode) {
+ClassifierDummyChannel::GetFetchCacheMode(uint32_t* aFetchCacheMode) {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-TrackingDummyChannel::SetFetchCacheMode(uint32_t aFetchCacheMode) {
+ClassifierDummyChannel::SetFetchCacheMode(uint32_t aFetchCacheMode) {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-TrackingDummyChannel::GetTopWindowURI(nsIURI** aTopWindowURI) {
+ClassifierDummyChannel::GetTopWindowURI(nsIURI** aTopWindowURI) {
   nsCOMPtr<nsIURI> topWindowURI = mTopWindowURI;
   topWindowURI.forget(aTopWindowURI);
   return mTopWindowURIResult;
 }
 
 NS_IMETHODIMP
-TrackingDummyChannel::SetTopWindowURIIfUnknown(nsIURI* aTopWindowURI) {
+ClassifierDummyChannel::SetTopWindowURIIfUnknown(nsIURI* aTopWindowURI) {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-TrackingDummyChannel::SetTopWindowPrincipal(nsIPrincipal* aTopWindowPrincipal) {
+ClassifierDummyChannel::SetTopWindowPrincipal(
+    nsIPrincipal* aTopWindowPrincipal) {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-TrackingDummyChannel::GetProxyURI(nsIURI** aProxyURI) {
+ClassifierDummyChannel::GetProxyURI(nsIURI** aProxyURI) {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
-void TrackingDummyChannel::SetCorsPreflightParameters(
+void ClassifierDummyChannel::SetCorsPreflightParameters(
     const nsTArray<nsCString>& aUnsafeHeaders) {}
 
-void TrackingDummyChannel::SetAltDataForChild(bool aIsForChild) {}
+void ClassifierDummyChannel::SetAltDataForChild(bool aIsForChild) {}
 
 NS_IMETHODIMP
-TrackingDummyChannel::GetBlockAuthPrompt(bool* aBlockAuthPrompt) {
+ClassifierDummyChannel::GetBlockAuthPrompt(bool* aBlockAuthPrompt) {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-TrackingDummyChannel::SetBlockAuthPrompt(bool aBlockAuthPrompt) {
+ClassifierDummyChannel::SetBlockAuthPrompt(bool aBlockAuthPrompt) {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-TrackingDummyChannel::GetIntegrityMetadata(nsAString& aIntegrityMetadata) {
+ClassifierDummyChannel::GetIntegrityMetadata(nsAString& aIntegrityMetadata) {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-TrackingDummyChannel::SetIntegrityMetadata(
+ClassifierDummyChannel::SetIntegrityMetadata(
     const nsAString& aIntegrityMetadata) {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-TrackingDummyChannel::GetConnectionInfoHashKey(
+ClassifierDummyChannel::GetConnectionInfoHashKey(
     nsACString& aConnectionInfoHashKey) {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-TrackingDummyChannel::GetLastRedirectFlags(uint32_t* aLastRedirectFlags) {
+ClassifierDummyChannel::GetLastRedirectFlags(uint32_t* aLastRedirectFlags) {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-TrackingDummyChannel::SetLastRedirectFlags(uint32_t aLastRedirectFlags) {
+ClassifierDummyChannel::SetLastRedirectFlags(uint32_t aLastRedirectFlags) {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-TrackingDummyChannel::GetNavigationStartTimeStamp(
+ClassifierDummyChannel::GetNavigationStartTimeStamp(
     TimeStamp* aNavigationStartTimeStamp) {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-TrackingDummyChannel::SetNavigationStartTimeStamp(
+ClassifierDummyChannel::SetNavigationStartTimeStamp(
     TimeStamp aNavigationStartTimeStamp) {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-TrackingDummyChannel::CancelByChannelClassifier(nsresult aErrorCode) {
+ClassifierDummyChannel::CancelByChannelClassifier(nsresult aErrorCode) {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
-void TrackingDummyChannel::SetIPv4Disabled() {}
+void ClassifierDummyChannel::SetIPv4Disabled() {}
 
-void TrackingDummyChannel::SetIPv6Disabled() {}
+void ClassifierDummyChannel::SetIPv6Disabled() {}
 
 }  // namespace net
 }  // namespace mozilla
rename from netwerk/protocol/http/TrackingDummyChannel.h
rename to netwerk/protocol/http/ClassifierDummyChannel.h
--- a/netwerk/protocol/http/TrackingDummyChannel.h
+++ b/netwerk/protocol/http/ClassifierDummyChannel.h
@@ -1,22 +1,22 @@
 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* vim: set sw=2 ts=8 et 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_net_TrackingDummyChannel_h
-#define mozilla_net_TrackingDummyChannel_h
+#ifndef mozilla_net_ClassifierDummyChannel_h
+#define mozilla_net_ClassifierDummyChannel_h
 
 #include "nsIChannel.h"
 #include <functional>
 
-#define TRACKING_DUMMY_CHANNEL_IID                   \
+#define CLASSIFIER_DUMMY_CHANNEL_IID                 \
   {                                                  \
     0x70ceb97d, 0xbfa6, 0x4255, {                    \
       0xb7, 0x08, 0xe1, 0xb4, 0x4a, 0x1e, 0x0e, 0x9a \
     }                                                \
   }
 
 class nsIChannel;
 
@@ -39,51 +39,52 @@ namespace net {
  * 2) it's a navigation request.
  *
  * This hack can be removed once Bug 1231208's new "parent intercept" mechanism
  * fully lands, the pref is enabled by default it stays enabled for long enough
  * to be confident we will never need/want to turn it off.  Then as part of bug
  * 1496997 we can remove this implementation.  Bug 1498259 covers removing this
  * hack in particular.
  */
-class TrackingDummyChannel final : public nsIChannel,
-                                   public nsIHttpChannelInternal {
+class ClassifierDummyChannel final : public nsIChannel,
+                                     public nsIHttpChannelInternal {
  public:
-  NS_DECLARE_STATIC_IID_ACCESSOR(TRACKING_DUMMY_CHANNEL_IID)
+  NS_DECLARE_STATIC_IID_ACCESSOR(CLASSIFIER_DUMMY_CHANNEL_IID)
 
   NS_DECL_THREADSAFE_ISUPPORTS
   NS_DECL_NSIREQUEST
   NS_DECL_NSICHANNEL
   NS_DECL_NSIHTTPCHANNELINTERNAL
 
   enum StorageAllowedState {
     eStorageGranted,
     eStorageDenied,
     eAsyncNeeded,
   };
 
   static StorageAllowedState StorageAllowed(
       nsIChannel* aChannel, const std::function<void(bool)>& aCallback);
 
-  TrackingDummyChannel(nsIURI* aURI, nsIURI* aTopWindowURI,
-                       nsresult aTopWindowURIResult, nsILoadInfo* aLoadInfo);
+  ClassifierDummyChannel(nsIURI* aURI, nsIURI* aTopWindowURI,
+                         nsresult aTopWindowURIResult, nsILoadInfo* aLoadInfo);
 
   uint32_t ClassificationFlags() const;
 
   void AddClassificationFlags(uint32_t);
 
  private:
-  ~TrackingDummyChannel();
+  ~ClassifierDummyChannel();
 
   nsCOMPtr<nsILoadInfo> mLoadInfo;
   nsCOMPtr<nsIURI> mURI;
   nsCOMPtr<nsIURI> mTopWindowURI;
   nsresult mTopWindowURIResult;
 
   uint32_t mClassificationFlags;
 };
 
-NS_DEFINE_STATIC_IID_ACCESSOR(TrackingDummyChannel, TRACKING_DUMMY_CHANNEL_IID)
+NS_DEFINE_STATIC_IID_ACCESSOR(ClassifierDummyChannel,
+                              CLASSIFIER_DUMMY_CHANNEL_IID)
 
 }  // namespace net
 }  // namespace mozilla
 
-#endif  // mozilla_net_TrackingDummyChannel_h
+#endif  // mozilla_net_ClassifierDummyChannel_h
rename from netwerk/protocol/http/TrackingDummyChannelChild.cpp
rename to netwerk/protocol/http/ClassifierDummyChannelChild.cpp
--- a/netwerk/protocol/http/TrackingDummyChannelChild.cpp
+++ b/netwerk/protocol/http/ClassifierDummyChannelChild.cpp
@@ -1,25 +1,25 @@
 /* -*- 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/. */
 
-#include "TrackingDummyChannelChild.h"
+#include "ClassifierDummyChannelChild.h"
 #include "mozilla/ipc/BackgroundUtils.h"
 #include "mozilla/ipc/URIUtils.h"
 #include "nsIChannel.h"
 #include "nsIURI.h"
 
 namespace mozilla {
 namespace net {
 
 /* static */
-bool TrackingDummyChannelChild::Create(
+bool ClassifierDummyChannelChild::Create(
     nsIHttpChannel* aChannel, nsIURI* aURI,
     const std::function<void(bool)>& aCallback) {
   MOZ_ASSERT(NS_IsMainThread());
 
   MOZ_ASSERT(aChannel);
   MOZ_ASSERT(aURI);
 
   nsCOMPtr<nsIHttpChannelInternal> httpChannelInternal =
@@ -32,47 +32,48 @@ bool TrackingDummyChannelChild::Create(
   nsCOMPtr<nsIURI> topWindowURI;
   nsresult topWindowURIResult =
       httpChannelInternal->GetTopWindowURI(getter_AddRefs(topWindowURI));
 
   nsCOMPtr<nsILoadInfo> loadInfo = aChannel->LoadInfo();
   Maybe<LoadInfoArgs> loadInfoArgs;
   mozilla::ipc::LoadInfoToLoadInfoArgs(loadInfo, &loadInfoArgs);
 
-  PTrackingDummyChannelChild* actor =
-      gNeckoChild->SendPTrackingDummyChannelConstructor(
+  PClassifierDummyChannelChild* actor =
+      gNeckoChild->SendPClassifierDummyChannelConstructor(
           aURI, topWindowURI, topWindowURIResult, loadInfoArgs);
   if (!actor) {
     return false;
   }
 
   bool isThirdParty =
       nsContentUtils::IsThirdPartyWindowOrChannel(nullptr, aChannel, aURI);
 
-  static_cast<TrackingDummyChannelChild*>(actor)->Initialize(
+  static_cast<ClassifierDummyChannelChild*>(actor)->Initialize(
       aChannel, aURI, isThirdParty, aCallback);
   return true;
 }
 
-TrackingDummyChannelChild::TrackingDummyChannelChild() : mIsThirdParty(false) {}
+ClassifierDummyChannelChild::ClassifierDummyChannelChild()
+    : mIsThirdParty(false) {}
 
-TrackingDummyChannelChild::~TrackingDummyChannelChild() = default;
+ClassifierDummyChannelChild::~ClassifierDummyChannelChild() = default;
 
-void TrackingDummyChannelChild::Initialize(
+void ClassifierDummyChannelChild::Initialize(
     nsIHttpChannel* aChannel, nsIURI* aURI, bool aIsThirdParty,
     const std::function<void(bool)>& aCallback) {
   MOZ_ASSERT(NS_IsMainThread());
 
   mChannel = aChannel;
   mURI = aURI;
   mIsThirdParty = aIsThirdParty;
   mCallback = aCallback;
 }
 
-mozilla::ipc::IPCResult TrackingDummyChannelChild::Recv__delete__(
+mozilla::ipc::IPCResult ClassifierDummyChannelChild::Recv__delete__(
     const uint32_t& aClassificationFlags) {
   MOZ_ASSERT(NS_IsMainThread());
 
   if (!mChannel) {
     return IPC_OK();
   }
 
   nsCOMPtr<nsIHttpChannel> channel = std::move(mChannel);
rename from netwerk/protocol/http/TrackingDummyChannelChild.h
rename to netwerk/protocol/http/ClassifierDummyChannelChild.h
--- a/netwerk/protocol/http/TrackingDummyChannelChild.h
+++ b/netwerk/protocol/http/ClassifierDummyChannelChild.h
@@ -1,38 +1,38 @@
 /* -*- 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_net_TrackingDummyChannelChild_h
-#define mozilla_net_TrackingDummyChannelChild_h
+#ifndef mozilla_net_ClassifierDummyChannelChild_h
+#define mozilla_net_ClassifierDummyChannelChild_h
 
-#include "mozilla/net/PTrackingDummyChannelChild.h"
+#include "mozilla/net/PClassifierDummyChannelChild.h"
 #include "nsCOMPtr.h"
 
 #include <functional>
 
 class nsIHttpChannel;
 class nsIURI;
 
 namespace mozilla {
 namespace net {
 
-class TrackingDummyChannelChild final : public PTrackingDummyChannelChild {
-  friend class PTrackingDummyChannelChild;
+class ClassifierDummyChannelChild final : public PClassifierDummyChannelChild {
+  friend class PClassifierDummyChannelChild;
 
  public:
   static bool Create(nsIHttpChannel* aChannel, nsIURI* aURI,
                      const std::function<void(bool)>& aCallback);
 
   // Used by PNeckoChild only!
-  TrackingDummyChannelChild();
-  ~TrackingDummyChannelChild();
+  ClassifierDummyChannelChild();
+  ~ClassifierDummyChannelChild();
 
  private:
   void Initialize(nsIHttpChannel* aChannel, nsIURI* aURI, bool aIsThirdParty,
                   const std::function<void(bool)>& aCallback);
 
   mozilla::ipc::IPCResult Recv__delete__(
       const uint32_t& aClassificationFlags) override;
 
@@ -40,9 +40,9 @@ class TrackingDummyChannelChild final : 
   nsCOMPtr<nsIURI> mURI;
   std::function<void(bool)> mCallback;
   bool mIsThirdParty;
 };
 
 }  // namespace net
 }  // namespace mozilla
 
-#endif  // mozilla_net_TrackingDummyChannelChild_h
+#endif  // mozilla_net_ClassifierDummyChannelChild_h
rename from netwerk/protocol/http/TrackingDummyChannelParent.cpp
rename to netwerk/protocol/http/ClassifierDummyChannelParent.cpp
--- a/netwerk/protocol/http/TrackingDummyChannelParent.cpp
+++ b/netwerk/protocol/http/ClassifierDummyChannelParent.cpp
@@ -1,54 +1,55 @@
 /* -*- 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/. */
 
-#include "TrackingDummyChannelParent.h"
+#include "ClassifierDummyChannelParent.h"
 #include "mozilla/net/AsyncUrlChannelClassifier.h"
 #include "mozilla/Unused.h"
 #include "nsIChannel.h"
 #include "nsIPrincipal.h"
 #include "nsNetUtil.h"
 
 namespace mozilla {
 namespace net {
 
-TrackingDummyChannelParent::TrackingDummyChannelParent() : mIPCActive(true) {}
-
-TrackingDummyChannelParent::~TrackingDummyChannelParent() = default;
+ClassifierDummyChannelParent::ClassifierDummyChannelParent()
+    : mIPCActive(true) {}
 
-void TrackingDummyChannelParent::Init(nsIURI* aURI, nsIURI* aTopWindowURI,
-                                      nsresult aTopWindowURIResult,
-                                      nsILoadInfo* aLoadInfo) {
+ClassifierDummyChannelParent::~ClassifierDummyChannelParent() = default;
+
+void ClassifierDummyChannelParent::Init(nsIURI* aURI, nsIURI* aTopWindowURI,
+                                        nsresult aTopWindowURIResult,
+                                        nsILoadInfo* aLoadInfo) {
   MOZ_ASSERT(mIPCActive);
 
-  RefPtr<TrackingDummyChannelParent> self = this;
+  RefPtr<ClassifierDummyChannelParent> self = this;
   auto onExit =
       MakeScopeExit([self] { Unused << Send__delete__(self, false); });
 
   if (!aURI) {
     return;
   }
 
-  RefPtr<TrackingDummyChannel> channel = new TrackingDummyChannel(
+  RefPtr<ClassifierDummyChannel> channel = new ClassifierDummyChannel(
       aURI, aTopWindowURI, aTopWindowURIResult, aLoadInfo);
 
   bool willCallback = NS_SUCCEEDED(AsyncUrlChannelClassifier::CheckChannel(
       channel, [self = std::move(self), channel]() {
         if (self->mIPCActive) {
           Unused << Send__delete__(self, channel->ClassificationFlags());
         }
       }));
 
   if (willCallback) {
     onExit.release();
   }
 }
 
-void TrackingDummyChannelParent::ActorDestroy(ActorDestroyReason aWhy) {
+void ClassifierDummyChannelParent::ActorDestroy(ActorDestroyReason aWhy) {
   mIPCActive = false;
 }
 
 }  // namespace net
 }  // namespace mozilla
rename from netwerk/protocol/http/TrackingDummyChannelParent.h
rename to netwerk/protocol/http/ClassifierDummyChannelParent.h
--- a/netwerk/protocol/http/TrackingDummyChannelParent.h
+++ b/netwerk/protocol/http/ClassifierDummyChannelParent.h
@@ -1,39 +1,40 @@
 /* -*- 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_net_TrackingDummyChannelParent_h
-#define mozilla_net_TrackingDummyChannelParent_h
+#ifndef mozilla_net_ClassifierDummyChannelParent_h
+#define mozilla_net_ClassifierDummyChannelParent_h
 
-#include "mozilla/net/PTrackingDummyChannelParent.h"
+#include "mozilla/net/PClassifierDummyChannelParent.h"
 #include "nsISupportsImpl.h"
 
 class nsILoadInfo;
 class nsIURI;
 
 namespace mozilla {
 namespace net {
 
-class TrackingDummyChannelParent final : public PTrackingDummyChannelParent {
+class ClassifierDummyChannelParent final
+    : public PClassifierDummyChannelParent {
  public:
-  NS_INLINE_DECL_REFCOUNTING(TrackingDummyChannelParent)
+  NS_INLINE_DECL_REFCOUNTING(ClassifierDummyChannelParent)
 
-  TrackingDummyChannelParent();
+  ClassifierDummyChannelParent();
 
   void Init(nsIURI* aURI, nsIURI* aTopWindowURI, nsresult aTopWindowURIResult,
             nsILoadInfo* aLoadInfo);
 
  private:
-  ~TrackingDummyChannelParent();
+  ~ClassifierDummyChannelParent();
 
   void ActorDestroy(ActorDestroyReason aWhy) override;
 
   bool mIPCActive;
 };
 
 }  // namespace net
 }  // namespace mozilla
 
-#endif  // mozilla_net_TrackingDummyChannelParent_h
+#endif  // mozilla_net_ClassifierDummyChannelParent_h
--- a/netwerk/protocol/http/HttpBaseChannel.cpp
+++ b/netwerk/protocol/http/HttpBaseChannel.cpp
@@ -21,16 +21,17 @@
 #include "nsIPrincipal.h"
 #include "nsIScriptError.h"
 #include "nsISeekableStream.h"
 #include "nsIStorageStream.h"
 #include "nsITimedChannel.h"
 #include "nsIEncodedChannel.h"
 #include "nsIApplicationCacheChannel.h"
 #include "nsIMutableArray.h"
+#include "nsIURIMutator.h"
 #include "nsEscape.h"
 #include "nsStreamListenerWrapper.h"
 #include "nsISecurityConsoleMessage.h"
 #include "nsURLHelper.h"
 #include "nsICookieService.h"
 #include "nsIStreamConverterService.h"
 #include "nsCRT.h"
 #include "nsContentUtils.h"
@@ -61,16 +62,17 @@
 #include "nsIURL.h"
 #include "nsIConsoleService.h"
 #include "mozilla/BinarySearch.h"
 #include "mozilla/DebugOnly.h"
 #include "mozilla/Move.h"
 #include "mozilla/net/PartiallySeekableInputStream.h"
 #include "mozilla/net/UrlClassifierCommon.h"
 #include "mozilla/InputStreamLengthHelper.h"
+#include "mozilla/Tokenizer.h"
 #include "nsIHttpHeaderVisitor.h"
 #include "nsIMIMEInputStream.h"
 #include "nsIXULRuntime.h"
 #include "nsICacheInfoChannel.h"
 #include "nsIDOMWindowUtils.h"
 #include "nsIURIFixup.h"
 #include "nsHttpChannel.h"
 #include "nsRedirectHistoryEntry.h"
--- a/netwerk/protocol/http/HttpChannelChild.cpp
+++ b/netwerk/protocol/http/HttpChannelChild.cpp
@@ -57,17 +57,17 @@
 #include "nsIEventTarget.h"
 #include "nsIScriptError.h"
 #include "nsRedirectHistoryEntry.h"
 #include "nsSocketTransportService2.h"
 #include "nsStreamUtils.h"
 #include "nsThreadUtils.h"
 #include "nsCORSListenerProxy.h"
 #include "nsApplicationCache.h"
-#include "TrackingDummyChannel.h"
+#include "ClassifierDummyChannel.h"
 
 #ifdef MOZ_TASK_TRACER
 #  include "GeckoTaskTracer.h"
 #endif
 
 #ifdef MOZ_GECKO_PROFILER
 #  include "ProfilerMarkerPayload.h"
 #endif
@@ -2529,29 +2529,29 @@ HttpChannelChild::AsyncOpen(nsIStreamLis
       self->mInterceptListener = new InterceptStreamListener(self, nullptr);
 
       RefPtr<InterceptedChannelContent> intercepted =
           new InterceptedChannelContent(
               self, controller, self->mInterceptListener, shouldUpgrade);
       intercepted->NotifyController();
     };
 
-    TrackingDummyChannel::StorageAllowedState state =
-        TrackingDummyChannel::StorageAllowed(this, callback);
-    if (state == TrackingDummyChannel::eStorageGranted) {
+    ClassifierDummyChannel::StorageAllowedState state =
+        ClassifierDummyChannel::StorageAllowed(this, callback);
+    if (state == ClassifierDummyChannel::eStorageGranted) {
       callback(true);
       return NS_OK;
     }
 
-    if (state == TrackingDummyChannel::eAsyncNeeded) {
+    if (state == ClassifierDummyChannel::eAsyncNeeded) {
       // The async callback will be executed eventually.
       return NS_OK;
     }
 
-    MOZ_ASSERT(state == TrackingDummyChannel::eStorageDenied);
+    MOZ_ASSERT(state == ClassifierDummyChannel::eStorageDenied);
     // Fall through
   }
 
   return ContinueAsyncOpen();
 }
 
 // Assigns an nsIEventTarget to our IPDL actor so that IPC messages are sent to
 // the correct DocGroup/TabGroup.
rename from netwerk/protocol/http/PTrackingDummyChannel.ipdl
rename to netwerk/protocol/http/PClassifierDummyChannel.ipdl
--- a/netwerk/protocol/http/PTrackingDummyChannel.ipdl
+++ b/netwerk/protocol/http/PClassifierDummyChannel.ipdl
@@ -29,17 +29,17 @@ namespace net {
 // ServiceWorker initially determines that the channel should be intercepted and
 // 2) it's a navigation request.
 //
 // This hack can be removed once Bug 1231208's new "parent intercept" mechanism
 // fully lands, the pref is enabled by default it stays enabled for long enough
 // to be confident we will never need/want to turn it off.  Then as part of bug
 // 1496997 we can remove this implementation.  Bug 1498259 covers removing this
 // hack in particular.
-protocol PTrackingDummyChannel
+protocol PClassifierDummyChannel
 {
   manager PNecko;
 
 child:
   async __delete__(uint32_t aClassificationFlags);
 };
 
 } // namespace net
--- a/netwerk/protocol/http/moz.build
+++ b/netwerk/protocol/http/moz.build
@@ -34,44 +34,47 @@ EXPORTS += [
     'nsHttpRequestHead.h',
     'nsHttpResponseHead.h',
 ]
 
 EXPORTS.mozilla.net += [
     'AltDataOutputStreamChild.h',
     'AltDataOutputStreamParent.h',
     'BackgroundChannelRegistrar.h',
+    'ClassifierDummyChannel.h',
+    'ClassifierDummyChannelChild.h',
+    'ClassifierDummyChannelParent.h',
     'HttpAuthUtils.h',
     'HttpBackgroundChannelChild.h',
     'HttpBackgroundChannelParent.h',
     'HttpBaseChannel.h',
     'HttpChannelChild.h',
     'HttpChannelParent.h',
     'HttpInfo.h',
     'nsServerTiming.h',
     'NullHttpChannel.h',
     'PHttpChannelParams.h',
     'PSpdyPush.h',
     'TimingStruct.h',
-    'TrackingDummyChannel.h',
-    'TrackingDummyChannelChild.h',
-    'TrackingDummyChannelParent.h',
 ]
 
 SOURCES += [
     'nsHttpChannelAuthProvider.cpp', # redefines GetAuthType
 ]
 
 UNIFIED_SOURCES += [
     'AltDataOutputStreamChild.cpp',
     'AltDataOutputStreamParent.cpp',
     'AlternateServices.cpp',
     'ASpdySession.cpp',
     'BackgroundChannelRegistrar.cpp',
     'CacheControlParser.cpp',
+    'ClassifierDummyChannel.cpp',
+    'ClassifierDummyChannelChild.cpp',
+    'ClassifierDummyChannelParent.cpp',
     'ConnectionDiagnostics.cpp',
     'DelayHttpChannelQueue.cpp',
     'Http2Compression.cpp',
     'Http2Push.cpp',
     'Http2Session.cpp',
     'Http2Stream.cpp',
     'HttpAuthUtils.cpp',
     'HttpBackgroundChannelChild.cpp',
@@ -98,32 +101,29 @@ UNIFIED_SOURCES += [
     'nsHttpHeaderArray.cpp',
     'nsHttpNTLMAuth.cpp',
     'nsHttpRequestHead.cpp',
     'nsHttpResponseHead.cpp',
     'nsHttpTransaction.cpp',
     'nsServerTiming.cpp',
     'NullHttpChannel.cpp',
     'NullHttpTransaction.cpp',
-    'TrackingDummyChannel.cpp',
-    'TrackingDummyChannelChild.cpp',
-    'TrackingDummyChannelParent.cpp',
     'TunnelUtils.cpp',
 ]
 
 # These files cannot be built in unified mode because of OS X headers.
 SOURCES += [
     'nsHttpHandler.cpp',
 ]
 
 IPDL_SOURCES += [
     'PAltDataOutputStream.ipdl',
+    'PClassifierDummyChannel.ipdl',
     'PHttpBackgroundChannel.ipdl',
     'PHttpChannel.ipdl',
-    'PTrackingDummyChannel.ipdl',
 ]
 
 EXTRA_JS_MODULES += [
     'UserAgentOverrides.jsm',
     'UserAgentUpdates.jsm',
 ]
 
 include('/ipc/chromium/chromium-config.mozbuild')
--- a/netwerk/url-classifier/UrlClassifierCommon.cpp
+++ b/netwerk/url-classifier/UrlClassifierCommon.cpp
@@ -1,16 +1,17 @@
 /* -*- 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/. */
 
 #include "mozilla/net/UrlClassifierCommon.h"
 
+#include "ClassifierDummyChannel.h"
 #include "mozilla/AntiTrackingCommon.h"
 #include "mozilla/BasePrincipal.h"
 #include "mozilla/net/HttpBaseChannel.h"
 #include "mozilla/net/UrlClassifierFeatureFactory.h"
 #include "mozilla/StaticPrefs.h"
 #include "mozIThirdPartyUtil.h"
 #include "nsContentUtils.h"
 #include "nsIChannel.h"
@@ -19,17 +20,16 @@
 #include "nsIDocShell.h"
 #include "nsIHttpChannel.h"
 #include "nsIHttpChannelInternal.h"
 #include "nsIParentChannel.h"
 #include "nsIScriptError.h"
 #include "nsIWebProgressListener.h"
 #include "nsNetUtil.h"
 #include "nsQueryObject.h"
-#include "TrackingDummyChannel.h"
 
 namespace mozilla {
 namespace net {
 
 const nsCString::size_type UrlClassifierCommon::sMaxSpecLength = 128;
 
 // MOZ_LOG=nsChannelClassifier:5
 LazyLogModule UrlClassifierCommon::sLog("nsChannelClassifier");
@@ -294,17 +294,17 @@ void SetClassificationFlagsHelper(nsICha
                                              aIsThirdParty);
   }
 
   RefPtr<HttpBaseChannel> httpChannel = do_QueryObject(aChannel);
   if (httpChannel) {
     httpChannel->AddClassificationFlags(aClassificationFlags, aIsThirdParty);
   }
 
-  RefPtr<TrackingDummyChannel> dummyChannel = do_QueryObject(aChannel);
+  RefPtr<ClassifierDummyChannel> dummyChannel = do_QueryObject(aChannel);
   if (dummyChannel) {
     dummyChannel->AddClassificationFlags(aClassificationFlags);
   }
 }
 
 void LowerPriorityHelper(nsIChannel* aChannel) {
   MOZ_ASSERT(aChannel);
 
--- a/xpcom/io/InputStreamLengthHelper.h
+++ b/xpcom/io/InputStreamLengthHelper.h
@@ -1,14 +1,17 @@
 /* -*- 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_InputStreamLengthHelper_h
+#define mozilla_InputStreamLengthHelper_h
+
 #include "nsISupportsImpl.h"
 #include "nsIInputStreamLength.h"
 
 class nsIInputStream;
 
 namespace mozilla {
 
 // This class helps to retrieve the stream's length.
@@ -42,8 +45,10 @@ class InputStreamLengthHelper final : pu
 
   void ExecCallback(int64_t aLength);
 
   nsCOMPtr<nsIInputStream> mStream;
   std::function<void(int64_t aLength)> mCallback;
 };
 
 }  // namespace mozilla
+
+#endif // mozilla_InputStreamLengthHelper_h