Bug 1968644 - Part 3: Populate the triggeringFirstPartyClassificationFlags and triggeringThirdPartyClassificationFlags for fetch requests. r=valentin,smaug

Differential Revision: https://phabricator.services.mozilla.com/D252444

Author: artines1

dom/base/Document.cpp

@@ -4488,9 +4488,10 @@ nsresult Document::Dispatch(already_AddRefed<nsIRunnable>&& aRunnable) const {
 }
 
 void Document::NoteScriptTrackingStatus(const nsACString& aURL,
-                                        bool aIsTracking) {
-  if (aIsTracking) {
-    mTrackingScripts.Insert(aURL);
+                                        net::ClassificationFlags& aFlags) {
+  // If the script is not tracking, we don't need to do anything.
+  if (aFlags.firstPartyFlags || aFlags.thirdPartyFlags) {
+    mTrackingScripts.InsertOrUpdate(aURL, aFlags);
   }
   // Ideally, whether a given script is tracking or not should be consistent,
   // but there is a race so that it is not, when loading real sites in debug
@@ -4503,7 +4504,27 @@ bool Document::IsScriptTracking(JSContext* aCx) const {
   if (!JS::DescribeScriptedCaller(&filename, aCx)) {
     return false;
   }
-  return mTrackingScripts.Contains(nsDependentCString(filename.get()));
+
+  auto entry = mTrackingScripts.Lookup(nsDependentCString(filename.get()));
+  if (!entry) {
+    return false;
+  }
+
+  return net::UrlClassifierCommon::IsTrackingClassificationFlag(
+      entry.Data().thirdPartyFlags, IsInPrivateBrowsing());
+}
+
+net::ClassificationFlags Document::GetScriptTrackingFlags() const {
+  if (auto loc = JSCallingLocation::Get()) {
+    if (auto entry = mTrackingScripts.Lookup(loc.FileName())) {
+      return entry.Data();
+    }
+  }
+
+  // If the currently executing script is not a tracker, return the
+  // classification flags of the document.
+
+  return mClassificationFlags;
 }
 
 void Document::GetContentType(nsAString& aContentType) {

dom/base/Document.h

@@ -71,6 +71,7 @@
 #include "nsHashKeys.h"
 #include "nsIChannel.h"
 #include "nsIChannelEventSink.h"
+#include "nsIClassifiedChannel.h"
 #include "nsID.h"
 #include "nsIDocumentViewer.h"
 #include "nsIInterfaceRequestor.h"
@@ -3888,11 +3889,17 @@ class Document : public nsINode,
   // The URLs passed to this function should match what
   // JS::DescribeScriptedCaller() returns, since this API is used to
   // determine whether some code is being called from a tracking script.
-  void NoteScriptTrackingStatus(const nsACString& aURL, bool isTracking);
+  void NoteScriptTrackingStatus(const nsACString& aURL,
+                                net::ClassificationFlags& aFlags);
   // The JSContext passed to this method represents the context that we want to
   // determine if it belongs to a tracker.
   bool IsScriptTracking(JSContext* aCx) const;
 
+  // Acquires the script tracking flags for the currently executing script. If
+  // the currently executing script is not a tracker, it will return the
+  // classification flags of the document.
+  net::ClassificationFlags GetScriptTrackingFlags() const;
+
   // ResizeObserver usage.
   void AddResizeObserver(ResizeObserver& aObserver) {
     MOZ_ASSERT(!mResizeObservers.Contains(&aObserver));
@@ -5299,10 +5306,10 @@ class Document : public nsINode,
 
   RefPtr<nsCommandManager> mMidasCommandManager;
 
-  // The set of all the tracking script URLs.  URLs are added to this set by
+  // The hashmap of all the tracking script URLs.  URLs are added to this map by
   // calling NoteScriptTrackingStatus().  Currently we assume that a URL not
-  // existing in the set means the corresponding script isn't a tracking script.
-  nsTHashSet<nsCString> mTrackingScripts;
+  // existing in the map means the corresponding script isn't a tracking script.
+  nsTHashMap<nsCStringHashKey, net::ClassificationFlags> mTrackingScripts;
 
   // Pointer to our parser if we're currently in the process of being
   // parsed into.

dom/fetch/Fetch.cpp

@@ -15,6 +15,7 @@
 #include "mozilla/ipc/PBackgroundChild.h"
 #include "mozilla/ipc/PBackgroundSharedTypes.h"
 #include "mozilla/ipc/IPCStreamUtils.h"
+#include "nsIClassifiedChannel.h"
 #include "nsIGlobalObject.h"
 
 #include "nsDOMString.h"
@@ -450,7 +451,8 @@ class MainThreadFetchRunnable : public Runnable {
       fetch = new FetchDriver(mRequest.clonePtr(), principal, loadGroup,
                               workerPrivate->MainThreadEventTarget(),
                               workerPrivate->CookieJarSettings(),
-                              workerPrivate->GetPerformanceStorage(), false);
+                              workerPrivate->GetPerformanceStorage(),
+                              net::ClassificationFlags({0, 0}));
       nsAutoCString spec;
       if (proxy->GetWorkerPrivate()->GetBaseURI()) {
         proxy->GetWorkerPrivate()->GetBaseURI()->GetAsciiSpec(spec);
@@ -560,7 +562,7 @@ already_AddRefed<Promise> FetchRequest(nsIGlobalObject* aGlobal,
     nsCOMPtr<nsILoadGroup> loadGroup;
     nsCOMPtr<nsICookieJarSettings> cookieJarSettings;
     nsIPrincipal* principal;
-    bool isTrackingFetch = false;
+    net::ClassificationFlags trackingFlags = {0, 0};
     if (window) {
       doc = window->GetExtantDoc();
       if (!doc) {
@@ -571,7 +573,7 @@ already_AddRefed<Promise> FetchRequest(nsIGlobalObject* aGlobal,
       loadGroup = doc->GetDocumentLoadGroup();
       cookieJarSettings = doc->CookieJarSettings();
 
-      isTrackingFetch = doc->IsScriptTracking(cx);
+      trackingFlags = doc->GetScriptTrackingFlags();
     } else {
       principal = aGlobal->PrincipalOrNull();
       if (NS_WARN_IF(!principal)) {
@@ -596,7 +598,7 @@ already_AddRefed<Promise> FetchRequest(nsIGlobalObject* aGlobal,
         new FetchDriver(std::move(internalRequest), principal, loadGroup,
                         aGlobal->SerialEventTarget(), cookieJarSettings,
                         nullptr,  // PerformanceStorage
-                        isTrackingFetch);
+                        trackingFlags);
     fetch->SetDocument(doc);
     resolver->SetLoadGroup(loadGroup);
     aRv = fetch->Fetch(signalImpl, resolver);
@@ -1694,7 +1696,7 @@ void FetchBody<Derived>::MaybeTeeReadableStreamBody(
     return;
   }
 
-  nsTArray<RefPtr<ReadableStream> > branches;
+  nsTArray<RefPtr<ReadableStream>> branches;
   MOZ_KnownLive(mReadableStreamBody)->Tee(aCx, branches, aRv);
   if (aRv.Failed()) {
     return;

dom/fetch/FetchDriver.cpp

@@ -341,7 +341,7 @@ FetchDriver::FetchDriver(SafeRefPtr<InternalRequest> aRequest,
                          nsIEventTarget* aMainThreadEventTarget,
                          nsICookieJarSettings* aCookieJarSettings,
                          PerformanceStorage* aPerformanceStorage,
-                         bool aIsTrackingFetch)
+                         net::ClassificationFlags aTrackingFlags)
     : mPrincipal(aPrincipal),
       mLoadGroup(aLoadGroup),
       mRequest(std::move(aRequest)),
@@ -350,7 +350,7 @@ FetchDriver::FetchDriver(SafeRefPtr<InternalRequest> aRequest,
       mCookieJarSettings(aCookieJarSettings),
       mPerformanceStorage(aPerformanceStorage),
       mNeedToObserveOnDataAvailable(false),
-      mIsTrackingFetch(aIsTrackingFetch),
+      mTrackingFlags(aTrackingFlags),
       mIsOn3PCBExceptionList(false),
       mOnStopRequestCalled(false)
 #ifdef DEBUG
@@ -364,6 +364,9 @@ FetchDriver::FetchDriver(SafeRefPtr<InternalRequest> aRequest,
   MOZ_ASSERT(mRequest);
   MOZ_ASSERT(aPrincipal);
   MOZ_ASSERT(aMainThreadEventTarget);
+
+  mIsTrackingFetch = net::UrlClassifierCommon::IsTrackingClassificationFlag(
+      mTrackingFlags.thirdPartyFlags, false);
 }
 
 FetchDriver::~FetchDriver() {
@@ -693,6 +696,14 @@ nsresult FetchDriver::HttpFetch(
     NS_ENSURE_SUCCESS(rv, rv);
   }
 
+  nsCOMPtr<nsILoadInfo> loadInfo = chan->LoadInfo();
+  rv = loadInfo->SetTriggeringFirstPartyClassificationFlags(
+      mTrackingFlags.firstPartyFlags);
+  NS_ENSURE_SUCCESS(rv, rv);
+  rv = loadInfo->SetTriggeringThirdPartyClassificationFlags(
+      mTrackingFlags.thirdPartyFlags);
+  NS_ENSURE_SUCCESS(rv, rv);
+
   // If the fetch is created by FetchEvent.request or NavigationPreload request,
   // corresponding InterceptedHttpChannel information need to propagate to the
   // channel of the fetch.

dom/fetch/FetchDriver.h

@@ -8,6 +8,7 @@
 #define mozilla_dom_FetchDriver_h
 
 #include "nsIChannelEventSink.h"
+#include "nsIClassifiedChannel.h"
 #include "nsIInterfaceRequestor.h"
 #include "nsINetworkInterceptController.h"
 #include "nsIStreamListener.h"
@@ -112,7 +113,8 @@ class FetchDriver final : public nsIChannelEventSink,
   FetchDriver(SafeRefPtr<InternalRequest> aRequest, nsIPrincipal* aPrincipal,
               nsILoadGroup* aLoadGroup, nsIEventTarget* aMainThreadEventTarget,
               nsICookieJarSettings* aCookieJarSettings,
-              PerformanceStorage* aPerformanceStorage, bool aIsTrackingFetch);
+              PerformanceStorage* aPerformanceStorage,
+              net::ClassificationFlags aTrackingFlags);
 
   nsresult Fetch(AbortSignalImpl* aSignalImpl, FetchDriverObserver* aObserver);
 
@@ -191,6 +193,7 @@ class FetchDriver final : public nsIChannelEventSink,
   bool mNeedToObserveOnDataAvailable;
 
   bool mIsTrackingFetch;
+  net::ClassificationFlags mTrackingFlags;
 
   // Indicates whether the fetch request is from a third-party context.
   Maybe<bool> mIsThirdPartyContext;

dom/fetch/FetchService.cpp

@@ -265,7 +265,7 @@ RefPtr<FetchServicePromises> FetchService::FetchInstance::Fetch() {
       // tracking fetch to false, but for Keepalive
       // requests from main thread this needs to be
       // changed. See Bug 1892406
-      false  // IsTrackingFetch
+      net::ClassificationFlags({0, 0})  // TrackingFlags
   );
 
   if (mArgsType == FetchArgsType::WorkerFetch) {

dom/script/ScriptLoadContext.cpp

@@ -61,7 +61,7 @@ ScriptLoadContext::ScriptLoadContext(
       mIsNonAsyncScriptInserted(false),
       mIsXSLT(false),
       mInCompilingList(false),
-      mIsTracking(false),
+      mClassificationFlags({0, 0}),
       mWasCompiledOMT(false),
       mLineNo(1),
       mColumnNo(0),

dom/script/ScriptLoadContext.h

@@ -26,6 +26,7 @@
 #include "mozilla/Maybe.h"
 #include "mozilla/MaybeOneOf.h"
 #include "mozilla/Mutex.h"
+#include "mozilla/net/UrlClassifierCommon.h"
 #include "mozilla/PreloaderBase.h"
 #include "mozilla/RefPtr.h"
 #include "mozilla/StaticPrefs_dom.h"
@@ -35,6 +36,7 @@
 #include "mozilla/Vector.h"
 #include "nsCOMPtr.h"
 #include "nsCycleCollectionParticipant.h"
+#include "nsIClassifiedChannel.h"
 #include "nsIScriptElement.h"
 
 class nsICacheInfoChannel;
@@ -151,10 +153,12 @@ class ScriptLoadContext : public JS::loader::LoadContextBase,
 
   bool CompileStarted() const;
 
-  bool IsTracking() const { return mIsTracking; }
-  void SetIsTracking() {
-    MOZ_ASSERT(!mIsTracking);
-    mIsTracking = true;
+  net::ClassificationFlags& GetClassificationFlags() {
+    return mClassificationFlags;
+  }
+  void SetClassificationFlags(
+      const net::ClassificationFlags& aClassificationFlags) {
+    mClassificationFlags = aClassificationFlags;
   }
 
   void BlockOnload(Document* aDocument);
@@ -290,11 +294,11 @@ class ScriptLoadContext : public JS::loader::LoadContextBase,
   bool mIsNonAsyncScriptInserted;  // True if we live in
                                    // mNonAsyncExternalScriptInsertedRequests
   bool mIsXSLT;                    // True if we live in mXSLTRequests.
-  bool mInCompilingList;  // True if we are in mOffThreadCompilingRequests.
-  bool mIsTracking;       // True if the script comes from a source on our
-                          // tracking protection list.
-  bool mWasCompiledOMT;   // True if the script has been compiled off main
-                          // thread.
+  bool mInCompilingList;     // True if we are in mOffThreadCompilingRequests.
+  net::ClassificationFlags   // Classification flags
+      mClassificationFlags;  // of the source of the script.
+  bool mWasCompiledOMT;      // True if the script has been compiled off main
+                             // thread.
 
   // Task that performs off-thread compilation or off-thread decode.
   // This field is used to take the result of the task, or cancel the task.

dom/script/ScriptLoader.cpp

@@ -1001,7 +1001,11 @@ nsresult ScriptLoader::StartLoadInternal(
 
   LOG(("ScriptLoadRequest (%p): mode=%u tracking=%d", aRequest,
        unsigned(aRequest->GetScriptLoadContext()->mScriptMode),
-       aRequest->GetScriptLoadContext()->IsTracking()));
+       net::UrlClassifierCommon::IsTrackingClassificationFlag(
+           aRequest->GetScriptLoadContext()
+               ->GetClassificationFlags()
+               .thirdPartyFlags,
+           NS_UsePrivateBrowsing(channel))));
 
   PrepareRequestPriorityAndRequestDependencies(channel, aRequest);
 
@@ -2593,7 +2597,8 @@ nsresult ScriptLoader::FillCompileOptionsForRequest(
 
   if (mDocument) {
     mDocument->NoteScriptTrackingStatus(
-        aRequest->mURL, aRequest->GetScriptLoadContext()->IsTracking());
+        aRequest->mURL,
+        aRequest->GetScriptLoadContext()->GetClassificationFlags());
   }
 
   const char* introductionType;
@@ -4392,7 +4397,10 @@ nsresult ScriptLoader::PrepareLoadedRequest(ScriptLoadRequest* aRequest,
     MOZ_ASSERT(classifiedChannel);
     if (classifiedChannel &&
         classifiedChannel->IsThirdPartyTrackingResource()) {
-      aRequest->GetScriptLoadContext()->SetIsTracking();
+      net::ClassificationFlags flags{
+          classifiedChannel->GetFirstPartyClassificationFlags(),
+          classifiedChannel->GetThirdPartyClassificationFlags()};
+      aRequest->GetScriptLoadContext()->SetClassificationFlags(flags);
     }
   }
 

dom/xhr/XMLHttpRequestMainThread.cpp

@@ -65,6 +65,7 @@
 #include "nsStringStream.h"
 #include "nsIAuthPrompt.h"
 #include "nsIAuthPrompt2.h"
+#include "nsIClassifiedChannel.h"
 #include "nsIClassOfService.h"
 #include "nsIHttpChannel.h"
 #include "nsISupportsPriority.h"
@@ -2636,6 +2637,14 @@ nsresult XMLHttpRequestMainThread::CreateChannel() {
     NS_ENSURE_SUCCESS(rv, rv);
   }
 
+  if (nsCOMPtr<Document> doc = GetDocumentIfCurrent()) {
+    net::ClassificationFlags flags = doc->GetScriptTrackingFlags();
+    nsCOMPtr<nsILoadInfo> loadInfo = mChannel->LoadInfo();
+
+    loadInfo->SetTriggeringFirstPartyClassificationFlags(flags.firstPartyFlags);
+    loadInfo->SetTriggeringThirdPartyClassificationFlags(flags.thirdPartyFlags);
+  }
+
   nsCOMPtr<nsIHttpChannel> httpChannel(do_QueryInterface(mChannel));
   if (httpChannel) {
     rv = httpChannel->SetRequestMethod(mRequestMethod);