GitLab

at 2023-10-23T12:36:44+00:00

Bug 1738426 - Ignoring status 206 and vary header checking for opaque response in Cache API. r=asuth

Differential Revision: https://phabricator.services.mozilla.com/D186431
Bug 1802057 - Block the following characters from use in the cookie name in the cookie string: 0x3B (semi-colon), 0x3D (equals), and 0x7F (del) r=dveditz,cookie-reviewers

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

Bug 1819497 - Don't race on static bool for initialization. r=gfx-reviewers,aosmond

We could do non-racy static init here (e.g. with a static initializer
self-calling-closure), but there doesn't seem to be a strong reason for
this. Let's just use a switch and get robustness from -Werror=switch.

Differential Revision: https://phabricator.services.mozilla.com/D188054
Bug 1845752. r=ckerschb

Differential Revision: https://phabricator.services.mozilla.com/D186676
Bug 1850072: Initialize RecordedDrawTargetCreation::mHasExistingData. r=jrmuizel

This also specializes ElementStreamFormat for bool.

Differential Revision: https://phabricator.services.mozilla.com/D187794
Bug 1850200 - Add delay to HTTPS-Only "Continue to HTTPS Site" button r=freddyb

Differential Revision: https://phabricator.services.mozilla.com/D187887
Bug 1851803 - Introduce SourceMediaTrack::mDirectDisabledMode. r=karlt

Similar to MediaTrack::mDisabledMode, but this is for uses on the
SourceMediaTrack producer thread. It is still signaled via a control message
from the control thread to maintain order of operations, and is protected by the
SourceMediaTrack mutex.

Differential Revision: https://phabricator.services.mozilla.com/D187554
   aOut.statusText() = aIn.GetUnfilteredStatusText();

   RefPtr<InternalHeaders> headers = aIn.UnfilteredHeaders();

   MOZ_DIAGNOSTIC_ASSERT(headers);

-  if (HasVaryStar(headers)) {

+  if (aIn.Type() != ResponseType::Opaque && HasVaryStar(headers)) {

     aRv.ThrowTypeError("Invalid Response object with a 'Vary: *' header.");

     return;

   }

 namespace mozilla {

 const char* GetExtensionName(const WebGLExtensionID ext) {

-  static EnumeratedArray<WebGLExtensionID, WebGLExtensionID::Max, const char*>

-      sExtensionNamesEnumeratedArray;

-  static bool initialized = false;

-

-  if (!initialized) {

-    initialized = true;

-

+  switch (ext) {

 #define WEBGL_EXTENSION_IDENTIFIER(x) \

-  sExtensionNamesEnumeratedArray[WebGLExtensionID::x] = #x;

+  case WebGLExtensionID::x:           \

+    return #x;

     WEBGL_EXTENSION_IDENTIFIER(ANGLE_instanced_arrays)

     WEBGL_EXTENSION_IDENTIFIER(EXT_blend_minmax)

     WEBGL_EXTENSION_IDENTIFIER(WEBGL_provoking_vertex)

 #undef WEBGL_EXTENSION_IDENTIFIER

-  }

-  return sExtensionNamesEnumeratedArray[ext];

+    case WebGLExtensionID::Max:

+      break;

+  }

+  MOZ_CRASH("bad WebGLExtensionID");

 }

 // ----------------------------

 nsTHashMap<nsGenericHashKey<GraphKey>, MediaTrackGraphImpl*> gGraphs;

 }  // anonymous namespace

+static void ApplyTrackDisabling(DisabledTrackMode aDisabledMode,

+                                MediaSegment* aSegment,

+                                MediaSegment* aRawSegment) {

+  if (aDisabledMode == DisabledTrackMode::ENABLED) {

+    return;

+  }

+  if (aDisabledMode == DisabledTrackMode::SILENCE_BLACK) {

+    aSegment->ReplaceWithDisabled();

+    if (aRawSegment) {

+      aRawSegment->ReplaceWithDisabled();

+    }

+  } else if (aDisabledMode == DisabledTrackMode::SILENCE_FREEZE) {

+    aSegment->ReplaceWithNull();

+    if (aRawSegment) {

+      aRawSegment->ReplaceWithNull();

+    }

+  } else {

+    MOZ_CRASH("Unsupported mode");

+  }

+}

+

 MediaTrackGraphImpl::~MediaTrackGraphImpl() {

   MOZ_ASSERT(mTracks.IsEmpty() && mSuspendedTracks.IsEmpty(),

              "All tracks should have been destroyed by messages from the main "

 void MediaTrack::AddDirectListenerImpl(

     already_AddRefed<DirectMediaTrackListener> aListener) {

+  MOZ_ASSERT(mGraph->OnGraphThread());

   // Base implementation, for tracks that don't support direct track listeners.

   RefPtr<DirectMediaTrackListener> listener = aListener;

   listener->NotifyDirectListenerInstalled(

 }

 void MediaTrack::SetDisabledTrackModeImpl(DisabledTrackMode aMode) {

+  MOZ_ASSERT(mGraph->OnGraphThread());

   MOZ_DIAGNOSTIC_ASSERT(

       aMode == DisabledTrackMode::ENABLED ||

           mDisabledMode == DisabledTrackMode::ENABLED,

 void MediaTrack::ApplyTrackDisabling(MediaSegment* aSegment,

                                      MediaSegment* aRawSegment) {

-  if (mDisabledMode == DisabledTrackMode::ENABLED) {

-    return;

-  }

-  if (mDisabledMode == DisabledTrackMode::SILENCE_BLACK) {

-    aSegment->ReplaceWithDisabled();

-    if (aRawSegment) {

-      aRawSegment->ReplaceWithDisabled();

-    }

-  } else if (mDisabledMode == DisabledTrackMode::SILENCE_FREEZE) {

-    aSegment->ReplaceWithNull();

-    if (aRawSegment) {

-      aRawSegment->ReplaceWithNull();

-    }

-  } else {

-    MOZ_CRASH("Unsupported mode");

-  }

+  MOZ_ASSERT(mGraph->OnGraphThread());

+  mozilla::ApplyTrackDisabling(mDisabledMode, aSegment, aRawSegment);

 }

 void MediaTrack::AddMainThreadListener(

   // Apply track disabling before notifying any consumers directly

   // or inserting into the graph

-  ApplyTrackDisabling(aSegment, aRawSegment);

+  mozilla::ApplyTrackDisabling(mDirectDisabledMode, aSegment, aRawSegment);

   ResampleAudioToGraphSampleRate(aSegment);

 void SourceMediaTrack::AddDirectListenerImpl(

     already_AddRefed<DirectMediaTrackListener> aListener) {

+  MOZ_ASSERT(mGraph->OnGraphThread());

   MutexAutoLock lock(mMutex);

   RefPtr<DirectMediaTrackListener> listener = aListener;

 void SourceMediaTrack::RemoveDirectListenerImpl(

     DirectMediaTrackListener* aListener) {

+  mGraph->AssertOnGraphThreadOrNotRunning();

   MutexAutoLock lock(mMutex);

   for (int32_t i = mDirectTrackListeners.Length() - 1; i >= 0; --i) {

     const RefPtr<DirectMediaTrackListener>& l = mDirectTrackListeners[i];

 }

 void SourceMediaTrack::SetDisabledTrackModeImpl(DisabledTrackMode aMode) {

+  MOZ_ASSERT(mGraph->OnGraphThread());

   {

     MutexAutoLock lock(mMutex);

+    const DisabledTrackMode oldMode = mDirectDisabledMode;

+    const bool oldEnabled = oldMode == DisabledTrackMode::ENABLED;

+    const bool enabled = aMode == DisabledTrackMode::ENABLED;

+    mDirectDisabledMode = aMode;

     for (const auto& l : mDirectTrackListeners) {

-      DisabledTrackMode oldMode = mDisabledMode;

-      bool oldEnabled = oldMode == DisabledTrackMode::ENABLED;

-      if (!oldEnabled && aMode == DisabledTrackMode::ENABLED) {

+      if (!oldEnabled && enabled) {

         LOG(LogLevel::Debug, ("%p: SourceMediaTrack %p setting "

                               "direct listener enabled",

                               GraphImpl(), this));

         l->DecreaseDisabled(oldMode);

-      } else if (oldEnabled && aMode != DisabledTrackMode::ENABLED) {

+      } else if (oldEnabled && !enabled) {

         LOG(LogLevel::Debug, ("%p: SourceMediaTrack %p setting "

                               "direct listener disabled",

                               GraphImpl(), this));

    */

   void End();

-  // Overriding allows us to hold the mMutex lock while changing the track

-  // enable status

   void SetDisabledTrackModeImpl(DisabledTrackMode aMode) override;

-  // Overriding allows us to ensure mMutex is locked while changing the track

-  // enable status

-  void ApplyTrackDisabling(MediaSegment* aSegment,

-                           MediaSegment* aRawSegment = nullptr) override {

-    mMutex.AssertCurrentThreadOwns();

-    MediaTrack::ApplyTrackDisabling(aSegment, aRawSegment);

-  }

-

   uint32_t NumberOfChannels() const override;

   void RemoveAllDirectListenersImpl() override;

   // protected by mMutex

   float mVolume MOZ_GUARDED_BY(mMutex) = 1.0;

   UniquePtr<TrackData> mUpdateTrack MOZ_GUARDED_BY(mMutex);

+  // This track's associated disabled mode for uses on the producing thread.

+  // It can either by disabled by frames being replaced by black, or by

+  // retaining the previous frame.

+  DisabledTrackMode mDirectDisabledMode MOZ_GUARDED_BY(mMutex) =

+      DisabledTrackMode::ENABLED;

   nsTArray<RefPtr<DirectMediaTrackListener>> mDirectTrackListeners

       MOZ_GUARDED_BY(mMutex);

 };

   BackendType mBackendType;

   IntRect mRect;

   SurfaceFormat mFormat;

-  bool mHasExistingData;

+  bool mHasExistingData = false;

   RefPtr<SourceSurface> mExistingData;

  private:

     aStream.read(reinterpret_cast<char*>(&aElement), sizeof(T));

   }

 };

+template <class S>

+struct ElementStreamFormat<S, bool> {

+  static void Write(S& aStream, const bool& aElement) {

+    char boolChar = aElement ? '\x01' : '\x00';

+    aStream.write(&boolChar, sizeof(boolChar));

+  }

+  static void Read(S& aStream, bool& aElement) {

+    char boolChar;

+    aStream.read(&boolChar, sizeof(boolChar));

+    switch (boolChar) {

+      case '\x00':

+        aElement = false;

+        break;

+      case '\x01':

+        aElement = true;

+        break;

+      default:

+        aStream.SetIsBad();

+        break;

+    }

+  }

+};

 template <class S, class T>

 void WriteElement(S& aStream, const T& aElement) {

 bool CookieCommons::CheckName(const CookieStruct& aCookieData) {

   const char illegalNameCharacters[] = {

-      0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B,

-      0x0C, 0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16,

-      0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, 0x00};

+      0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C,

+      0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18,

+      0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, 0x3B, 0x3D, 0x7F, 0x00};

   const auto* start = aCookieData.name().BeginReading();

   const auto* end = aCookieData.name().EndReading();

   [Cookie with %xd in name is rejected (DOM).]

     expected: FAIL

-  [Cookie with %x7f in name is rejected (DOM).]

-    expected: FAIL

-

-  [Cookie with %x0 in name is rejected or modified (HTTP).]

-    expected: FAIL

-

-  [Cookie with %x1 in name is rejected (HTTP).]

-    expected: FAIL

-

-  [Cookie with %x2 in name is rejected (HTTP).]

-    expected: FAIL

-

-  [Cookie with %x3 in name is rejected (HTTP).]

-    expected: FAIL

-

-  [Cookie with %x4 in name is rejected (HTTP).]

-    expected: FAIL

-

-  [Cookie with %x5 in name is rejected (HTTP).]

-    expected: FAIL

-

-  [Cookie with %x6 in name is rejected (HTTP).]

-    expected: FAIL

-

-  [Cookie with %x7 in name is rejected (HTTP).]

-    expected: FAIL

-

-  [Cookie with %x8 in name is rejected (HTTP).]

-    expected: FAIL

-

   [Cookie with %x9 in name is accepted (HTTP).]

     expected: FAIL

-[cache-put.https.any.serviceworker.html]

-  expected:

-    if (os == "android") and fission: [OK, TIMEOUT]

-  [Cache.put with a VARY:* opaque response should not reject]

-    expected: FAIL

-

-

-[cache-put.https.any.sharedworker.html]

-  expected:

-    if (os == "android") and fission: [OK, TIMEOUT]

-  [Cache.put with a VARY:* opaque response should not reject]

-    expected: FAIL

-

-

-[cache-put.https.any.html]

-  expected:

-    if (os == "android") and fission: [OK, TIMEOUT]

-  [Cache.put with a VARY:* opaque response should not reject]

-    expected: FAIL

-

-

-[cache-put.https.any.worker.html]

-  expected:

-    if (os == "android") and fission: [OK, TIMEOUT]

-  [Cache.put with a VARY:* opaque response should not reject]

-    expected: FAIL
         <button

           id="openInsecure"

           data-l10n-id="about-httpsonly-button-continue-to-site"

+          inert

         ></button>

       </div>

       <div class="suggestion-box" hidden>

     .getElementById("openInsecure")

     .addEventListener("click", onOpenInsecureButtonClick);

+  const delay = RPMGetIntPref("security.dialog_enable_delay", 1000);

+  setTimeout(() => {

+    document.getElementById("openInsecure").removeAttribute("inert");

+  }, delay);

+

   if (window.top == window) {

     document

       .getElementById("goBack")

     lazy.logConsole.debug("_install: Downloading engine from:", loadURI.spec);

-    var chan = lazy.SearchUtils.makeChannel(loadURI);

+    var chan = lazy.SearchUtils.makeChannel(

+      loadURI,

+      // OpenSearchEngine is loading a definition file for a search engine,

+      // TYPE_DOCUMENT captures that load best

+      Ci.nsIContentPolicy.TYPE_DOCUMENT

+    );

     if (this._engineToUpdate && chan instanceof Ci.nsIHttpChannel) {

       var lastModified = this._engineToUpdate.getAttr("updatelastmodified");

           this._hasPreferredIcon = isPreferred;

         };

-        let chan = lazy.SearchUtils.makeChannel(uri);

+        let chan = lazy.SearchUtils.makeChannel(

+          uri,

+          Ci.nsIContentPolicy.TYPE_IMAGE

+        );

         let listener = new lazy.SearchUtils.LoadListener(

           chan,

           /^image\//,

    *

    * @param {string|nsIURI} url

    *   The URL string from which to create an nsIChannel.

+   * @param {nsIContentPolicy} contentPolicyType

+   *   The type of document being loaded.

    * @returns {nsIChannel}

    *   an nsIChannel object, or null if the url is invalid.

    */

-  makeChannel(url) {

+  makeChannel(url, contentPolicyType) {

+    if (!contentPolicyType) {

+      throw new Error("makeChannel called with invalid content policy type");

+    }

     try {

       let uri = typeof url == "string" ? Services.io.newURI(url) : url;

       return Services.io.newChannelFromURI(

         uri,

         null /* loadingNode */,

-        Services.scriptSecurityManager.getSystemPrincipal(),

+        Services.scriptSecurityManager.createNullPrincipal({}),

         null /* triggeringPrincipal */,

         Ci.nsILoadInfo.SEC_ALLOW_CROSS_ORIGIN_SEC_CONTEXT_IS_NULL,

-        Ci.nsIContentPolicy.TYPE_OTHER

+        contentPolicyType

       );

     } catch (ex) {}

   response.setStatusLine("1.1", 302, "Moved");

   if (request.queryString == "type=invalid") {

     response.setHeader("Content-Type", "image/png", false);

-    response.setHeader("Location", "engine.xml", false);

+    response.setHeader("Location", "/head_search.js", false);

   } else {

     response.setHeader("Content-Type", "text/html", false);

     response.setHeader("Location", "remoteIcon.ico", false);

 });

 add_task(async function test_installedresourceicon() {

+  // Attempts to load a resource:// url as an icon.

   let engine1 = await SearchTestUtils.promiseNewSearchEngine({

     url: `${gDataUrl}opensearch/resourceicon.xml`,

   });

+  // Attempts to load a chrome:// url as an icon.

   let engine2 = await SearchTestUtils.promiseNewSearchEngine({

     url: `${gDataUrl}opensearch/chromeicon.xml`,

   });

   // The easiest way to test adding the icon is via a generated xml, otherwise

   // we have to somehow insert the address of the server into it.

+  // Attempts to load a non-image page into an image icon.

   let engine = await SearchTestUtils.promiseNewSearchEngine({

     url:

       `${gDataUrl}data/engineMaker.sjs?` +

       JSON.stringify({

         baseURL: gDataUrl,

-        image: "opensearch/resourceicon.xml",

+        image: "head_search.js",

         name: "invalidicon",

         method: "GET",

       }),

 const { promiseShutdownManager, promiseStartupManager } = AddonTestUtils;

+let gBaseUrl;

+

 async function getEngineNames() {

   let engines = await Services.search.getEngines();

   return engines.map(engine => engine._name);

 add_task(async function setup() {

   let server = useHttpServer();

   server.registerContentType("sjs", "sjs");

+  gBaseUrl = `http://localhost:${server.identity.primaryPort}/`;

+

   await SearchTestUtils.useTestEngines("test-extensions");

   await promiseStartupManager();

   // User installs a new search engine

   let extension = await SearchTestUtils.installSearchExtension(

     {

-      favicon_url: `${gDataUrl}engine.xml`,

+      favicon_url: `${gBaseUrl}/head_search.js`,

     },

     { skipUnload: true }

   );

     },

     "about:httpsonlyerror": {

       RPMGetFormatURLPref: ["app.support.baseURL"],

+      RPMGetIntPref: ["security.dialog_enable_delay"],

       RPMSendAsyncMessage: ["goBack", "openInsecure"],

       RPMAddMessageListener: ["WWWReachable"],

       RPMTryPingSecureWWWLink: ["*"],

richard pushed to branch mullvad-browser-115.4.0esr-13.5-1 at The Tor Project / Applications / Mullvad Browser

Commits:

18 changed files:

Changes: