GitLab

at 2023-08-27T12:55:13+02:00

Bug 1751583. r=media-playback-reviewers,alwu a=RyanVM
Bug 1842030 - Part 1: Adding CanonicalBrowsingContext::IsPrivateBrowsingActive(). r=nika

The CanonicalBrowsingContext::IsPrivateBrowsingActive() function allows
us to know if private browsing is active. We need it to prevent setting
cookies if there is no active private browsing session.

Differential Revision: https://phabricator.services.mozilla.com/D184010
Bug 1842030 - Part 2: Check the global private browsing state for HttpBaseChannel::IsBrowsingContextDiscarded() if the loadGroup is not avaiable. r=necko-reviewers,jesup

The HttpBaseChannel::IsBrowsingContextDiscarded() did always return
false if the loadGroup is not avaiable. But, this may not be correct for
the private channels if the private session has been ended. To fix this,
we make the function to check the global private browsing state
if the loadGroup is not available for private channels.

Depends on D184010

Differential Revision: https://phabricator.services.mozilla.com/D184479
Bug 1843046: Do not allow notifications in private window. r=saschanaz, a=RyanVM

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

   return uniqueSiteOrigins.Count();

 }

+/* static */

+bool CanonicalBrowsingContext::IsPrivateBrowsingActive() {

+  return gNumberOfPrivateContexts > 0;

+}

+

 void CanonicalBrowsingContext::UpdateMediaControlAction(

     const MediaControlAction& aAction) {

   if (IsDiscarded()) {

       GlobalObject& aGlobal,

       const Sequence<mozilla::OwningNonNull<BrowsingContext>>& aRoots);

+  // Return true if a private browsing session is active.

+  static bool IsPrivateBrowsingActive();

+

   // This function would propogate the action to its all child browsing contexts

   // in content processes.

   void UpdateMediaControlAction(const MediaControlAction& aAction);

 #define __CLASS__ "GMPParent"

 GMPParent::GMPParent()

-    : mState(GMPStateNotLoaded),

+    : mState(GMPState::NotLoaded),

       mPluginId(GeckoChildProcessHost::GetUniqueID()),

       mProcess(nullptr),

       mDeleteProcessOnlyOnUnload(false),

 }

 void GMPParent::Crash() {

-  if (mState != GMPStateNotLoaded) {

+  if (mState != GMPState::NotLoaded) {

     Unused << SendCrashPluginNow();

   }

 }

 nsresult GMPParent::LoadProcess() {

   MOZ_ASSERT(mDirectory, "Plugin directory cannot be NULL!");

   MOZ_ASSERT(GMPEventTarget()->IsOnCurrentThread());

-  MOZ_ASSERT(mState == GMPStateNotLoaded);

+  MOZ_ASSERT(mState == GMPState::NotLoaded);

   nsAutoString path;

   if (NS_WARN_IF(NS_FAILED(mDirectory->GetPath(path)))) {

     GMP_PARENT_LOG_DEBUG("%s: Sent StartPlugin to child process", __FUNCTION__);

   }

-  mState = GMPStateLoaded;

+  mState = GMPState::Loaded;

   // Hold a self ref while the child process is alive. This ensures that

   // during shutdown the GMPParent stays alive long enough to

   MOZ_ASSERT(GMPEventTarget()->IsOnCurrentThread());

   GMP_PARENT_LOG_DEBUG("%s", __FUNCTION__);

-  if ((mDeleteProcessOnlyOnUnload || mState == GMPStateLoaded ||

-       mState == GMPStateUnloading) &&

+  if ((mDeleteProcessOnlyOnUnload || mState == GMPState::Loaded ||

+       mState == GMPState::Unloading) &&

       !IsUsed()) {

     // Ensure all timers are killed.

     for (uint32_t i = mTimers.Length(); i > 0; i--) {

 void GMPParent::CloseActive(bool aDieWhenUnloaded) {

   MOZ_ASSERT(GMPEventTarget()->IsOnCurrentThread());

-  GMP_PARENT_LOG_DEBUG("%s: state %d", __FUNCTION__, mState);

+  GMP_PARENT_LOG_DEBUG("%s: state %u", __FUNCTION__,

+                       uint32_t(GMPState(mState)));

   if (aDieWhenUnloaded) {

     mDeleteProcessOnlyOnUnload = true;  // don't allow this to go back...

   }

-  if (mState == GMPStateLoaded) {

-    mState = GMPStateUnloading;

+  if (mState == GMPState::Loaded) {

+    mState = GMPState::Unloading;

   }

-  if (mState != GMPStateNotLoaded && IsUsed()) {

+  if (mState != GMPState::NotLoaded && IsUsed()) {

     Unused << SendCloseActive();

     CloseIfUnused();

   }

   }

   MOZ_ASSERT(!IsUsed());

-  if (mState == GMPStateNotLoaded || mState == GMPStateClosing) {

+  if (mState == GMPState::NotLoaded || mState == GMPState::Closing) {

     return;

   }

     // Destroy ourselves and rise from the fire to save memory

     mService->ReAddOnGMPThread(self);

   }  // else we've been asked to die and stay dead

-  MOZ_ASSERT(mState == GMPStateNotLoaded);

+  MOZ_ASSERT(mState == GMPState::NotLoaded);

 }

 class NotifyGMPShutdownTask : public Runnable {

   MOZ_ASSERT(GMPEventTarget()->IsOnCurrentThread());

   GMP_PARENT_LOG_DEBUG("%s", __FUNCTION__);

-  if (mState != GMPStateClosing) {

+  if (mState != GMPState::Closing) {

     // Don't Close() twice!

     // Probably remove when bug 1043671 is resolved

-    mState = GMPStateClosing;

+    mState = GMPState::Closing;

     Close();

   }

   mProcess->Delete(NewRunnableMethod("gmp::GMPParent::ChildTerminated", this,

   mProcess = nullptr;

 #if defined(MOZ_WIDGET_ANDROID)

-  if (mState != GMPStateNotLoaded) {

+  if (mState != GMPState::NotLoaded) {

     nsCOMPtr<nsIEventTarget> launcherThread(GetIPCLauncher());

     MOZ_ASSERT(launcherThread);

   }

 #endif  // defined(MOZ_WIDGET_ANDROID)

-  mState = GMPStateNotLoaded;

+  mState = GMPState::NotLoaded;

   nsCOMPtr<nsIRunnable> r =

       new NotifyGMPShutdownTask(NS_ConvertUTF8toUTF16(mNodeId));

 }

 bool GMPParent::EnsureProcessLoaded() {

-  if (mState == GMPStateLoaded) {

-    return true;

-  }

-  if (mState == GMPStateClosing || mState == GMPStateUnloading) {

-    return false;

+  switch (mState) {

+    case GMPState::NotLoaded:

+      return NS_SUCCEEDED(LoadProcess());

+    case GMPState::Loaded:

+      return true;

+    case GMPState::Unloading:

+    case GMPState::Closing:

+      return false;

   }

-  nsresult rv = LoadProcess();

-

-  return NS_SUCCEEDED(rv);

+  MOZ_ASSERT_UNREACHABLE("Unhandled GMPState!");

+  return false;

 }

 void GMPParent::AddCrashAnnotations() {

   }

   // warn us off trying to close again

-  mState = GMPStateClosing;

+  mState = GMPState::Closing;

   mAbnormalShutdownInProgress = true;

   CloseActive(false);

     RefPtr<GMPParent> self(this);

     // Must not call Close() again in DeleteProcess(), as we'll recurse

     // infinitely if we do.

-    MOZ_ASSERT(mState == GMPStateClosing);

+    MOZ_ASSERT(mState == GMPState::Closing);

     DeleteProcess();

     // Note: final destruction will be Dispatched to ourself

     mService->ReAddOnGMPThread(self);

 #include "nsString.h"

 #include "nsTArray.h"

 #include "nsIFile.h"

+#include "mozilla/Atomics.h"

 #include "mozilla/MozPromise.h"

 namespace mozilla::gmp {

                        const nsCString& aAPI, const nsCString& aTag);

 };

-enum GMPState {

-  GMPStateNotLoaded,

-  GMPStateLoaded,

-  GMPStateUnloading,

-  GMPStateClosing

-};

+enum class GMPState : uint32_t { NotLoaded, Loaded, Unloading, Closing };

 class GMPContentParent;

                              uint32_t& aArchSet);

 #endif

-  GMPState mState;

+  Atomic<GMPState> mState;

   nsCOMPtr<nsIFile> mDirectory;  // plugin directory on disk

   nsString mName;  // base name of plugin on disk, UTF-16 because used for paths

   nsCString mDisplayName;  // name of plugin displayed to users

   MutexAutoLock lock(mMutex);

   for (const RefPtr<GMPParent>& gmp : mPlugins) {

-    if (gmp->State() != GMPState::GMPStateLoaded) {

+    if (gmp->State() != GMPState::Loaded) {

       // Plugins that are not in the Loaded state have no process attached to

       // them, and any IPC we would attempt to send them would be ignored (or

       // result in a warning on debug builds).

   {

     MutexAutoLock lock(mMutex);

     for (const RefPtr<GMPParent>& gmp : mPlugins) {

-      if (gmp->State() != GMPState::GMPStateLoaded) {

+      if (gmp->State() != GMPState::Loaded) {

         // Plugins that are not in the Loaded state have no process attached to

         // them, and any IPC we would attempt to send them would be ignored (or

         // result in a warning on debug builds).

     }

     RefPtr<GMPParent> gmp = mPlugins[i];

-    if (aDeleteFromDisk && gmp->State() != GMPStateNotLoaded) {

+    if (aDeleteFromDisk && gmp->State() != GMPState::NotLoaded) {

       // We have to wait for the child process to release its lib handle

       // before we can delete the GMP.

       inUse = true;

       }

     }

-    if (gmp->State() == GMPStateNotLoaded || !aCanDefer) {

+    if (gmp->State() == GMPState::NotLoaded || !aCanDefer) {

       // GMP not in use or shutdown is being forced; can shut it down now.

       deadPlugins.AppendElement(gmp);

       mPlugins.RemoveElementAt(i);

   bool blocked = false;

   if (isSystem) {

     mPermission = NotificationPermission::Granted;

+  } else if (mPrincipal->GetPrivateBrowsingId() != 0) {

+    mPermission = NotificationPermission::Denied;

+    blocked = true;

   } else {

     // File are automatically granted permission.

     aRv.Throw(NS_ERROR_UNEXPECTED);

     return nullptr;

   }

+

   nsCOMPtr<nsIPrincipal> principal = sop->GetPrincipal();

+  if (!principal) {

+    aRv.Throw(NS_ERROR_UNEXPECTED);

+    return nullptr;

+  }

   RefPtr<Promise> promise = Promise::Create(window->AsGlobal(), aRv);

   if (aRv.Failed()) {

   }

   nsCOMPtr<nsIPrincipal> principal = sop->GetPrincipal();

+  if (!principal) {

+    aRv.Throw(NS_ERROR_UNEXPECTED);

+    return NotificationPermission::Denied;

+  }

+

+  if (principal->GetPrivateBrowsingId() != 0) {

+    return NotificationPermission::Denied;

+  }

+

   return GetPermissionInternal(principal, aRv);

 }

 }

 bool HttpBaseChannel::IsBrowsingContextDiscarded() const {

-  return mLoadGroup && mLoadGroup->GetIsBrowsingContextDiscarded();

+  // If there is no loadGroup attached to the current channel, we check the

+  // global private browsing state for the private channel instead. For

+  // non-private channel, we will always return false here.

+  //

+  // Note that we can only access the global private browsing state in the

+  // parent process. So, we will fallback to just return false in the content

+  // process.

+  if (!mLoadGroup) {

+    if (!XRE_IsParentProcess()) {

+      return false;

+    }

+

+    return mLoadInfo->GetOriginAttributes().mPrivateBrowsingId != 0 &&

+           !dom::CanonicalBrowsingContext::IsPrivateBrowsingActive();

+  }

+

+  return mLoadGroup->GetIsBrowsingContextDiscarded();

 }

 // https://mikewest.github.io/corpp/#process-navigation-response

   friend class PrivateBrowsingChannel<HttpBaseChannel>;

   friend class InterceptFailedOnStop;

+  friend class HttpChannelParent;

  protected:

   // this section is for main-thread-only object

 #include "mozilla/net/NeckoParent.h"

 #include "mozilla/InputStreamLengthHelper.h"

 #include "mozilla/IntegerPrintfMacros.h"

+#include "mozilla/Preferences.h"

 #include "mozilla/ProfilerLabels.h"

 #include "mozilla/StoragePrincipalHelper.h"

 #include "mozilla/UniquePtr.h"

   LOG(("HttpChannelParent::SetCookie [this=%p]", this));

   MOZ_ASSERT(!mAfterOnStartRequestBegun);

   MOZ_ASSERT(mCookie.IsEmpty());

+

+  // The loadGroup of the channel in the parent process could be null in the

+  // XPCShell content process test, see test_cookiejars_wrap.js. In this case,

+  // we cannot explicitly set the loadGroup for the parent channel because it's

+  // created from the content process. To workaround this, we add a testing pref

+  // to skip this check.

+  if (!Preferences::GetBool(

+          "network.cookie.skip_browsing_context_check_in_parent_for_testing") &&

+      mChannel->IsBrowsingContextDiscarded()) {

+    return;

+  }

   mCookie = std::move(aCookie);

 }

   });

   chan.loadInfo.originAttributes = tests[i].originAttributes;

   chan.QueryInterface(Ci.nsIHttpChannel);

+

+  let loadGroup = Cc["@mozilla.org/network/load-group;1"].createInstance(

+    Ci.nsILoadGroup

+  );

+

+  if (chan.loadInfo.originAttributes.privateBrowsingId == 0) {

+    loadGroup.notificationCallbacks = Cu.createLoadContext();

+    chan.loadGroup = loadGroup;

+

+    chan.notificationCallbacks = Cu.createLoadContext();

+  } else {

+    loadGroup.notificationCallbacks = Cu.createPrivateLoadContext();

+    chan.loadGroup = loadGroup;

+

+    chan.notificationCallbacks = Cu.createPrivateLoadContext();

+  }

+

   return chan;

 }

     "network.cookieJarSettings.unblocked_for_testing",

     true

   );

+  Services.prefs.setBoolPref(

+    "network.cookie.skip_browsing_context_check_in_parent_for_testing",

+    true

+  );

   Services.prefs.setIntPref("network.cookie.cookieBehavior", 0);

   run_test_in_child("../unit/test_cookiejars.js");

 }

ma1 pushed to branch tor-browser-102.15.0esr-12.5-1 at The Tor Project / Applications / Tor Browser

Commits:

11 changed files:

Changes: