tor-browser

browser_decoderDoctor.js (11130B)

---

"use strict";

// 'data' contains the notification data object:
// - data.type must be provided.
// - data.isSolved and data.decoderDoctorReportId will be added if not provided
//   (false and "testReportId" resp.)
// - Other fields (e.g.: data.formats) may be provided as needed.
// 'notificationMessage': Expected message in the notification bar.
//   Falsy if nothing is expected after the notification is sent, in which case
//   we won't have further checks, so the following parameters are not needed.
// 'label': Expected button label. Falsy if no button is expected, in which case
//   we won't have further checks, so the following parameters are not needed.
// 'accessKey': Expected access key for the button.
// 'tabChecker': function(openedTab) called with the opened tab that resulted
//   from clicking the button.
async function test_decoder_doctor_notification(
 data,
 notificationMessage,
 label,
 accessKey,
 isLink,
 tabChecker
) {
 const TEST_URL = "https://example.org";
 // A helper closure to test notifications in same or different origins.
 // 'test_cross_origin' is used to determine if the observers used in the test
 // are notified in the same frame (when false) or in a cross origin iframe
 // (when true).
 async function create_tab_and_test(test_cross_origin) {
   await BrowserTestUtils.withNewTab(
     { gBrowser, url: TEST_URL },
     async function (browser) {
       let awaitNotificationBar;
       if (notificationMessage) {
         awaitNotificationBar = BrowserTestUtils.waitForNotificationBar(
           gBrowser,
           browser,
           "decoder-doctor-notification"
         );
       }

       await SpecialPowers.spawn(
         browser,
         [data, test_cross_origin],
         /* eslint-disable-next-line no-shadow */
         async function (data, test_cross_origin) {
           if (!test_cross_origin) {
             // Notify in the same origin.
             Services.obs.notifyObservers(
               content.window,
               "decoder-doctor-notification",
               JSON.stringify(data)
             );
             return;
             // Done notifying in the same origin.
           }

           // Notify in a different origin.
           const CROSS_ORIGIN_URL = "https://example.com";
           let frame = content.document.createElement("iframe");
           frame.src = CROSS_ORIGIN_URL;
           await new Promise(resolve => {
             frame.addEventListener("load", () => {
               resolve();
             });
             content.document.body.appendChild(frame);
           });

           await content.SpecialPowers.spawn(
             frame,
             [data],
             async function (
               /* eslint-disable-next-line no-shadow */
               data
             ) {
               Services.obs.notifyObservers(
                 content.window,
                 "decoder-doctor-notification",
                 JSON.stringify(data)
               );
             }
           );
           // Done notifying in a different origin.
         }
       );

       if (!notificationMessage) {
         ok(
           true,
           "Tested notifying observers with a nonsensical message, no effects expected"
         );
         return;
       }

       let notification;
       try {
         notification = await awaitNotificationBar;
       } catch (ex) {
         ok(false, ex);
         return;
       }
       ok(notification, "Got decoder-doctor-notification notification");
       if (label?.l10nId) {
         // Without the following statement, the
         // test_cannot_initialize_pulseaudio
         // will permanently fail on Linux.
         if (label.l10nId === "moz-support-link-text") {
           MozXULElement.insertFTLIfNeeded(
             "toolkit/global/mozSupportLink.ftl"
           );
         }
         label = await document.l10n.formatValue(label.l10nId);
       }
       if (isLink) {
         let link = notification.supportLinkEls[0];
         if (link) {
           // Seems to be a Windows specific quirk, but without this
           // mutation observer the notification.messageText.textContent
           // will not be updated. This will cause consistent failures
           // on Windows.
           await BrowserTestUtils.waitForMutationCondition(
             link,
             { childList: true },
             () => link.textContent.trim()
           );
         }
       }
       is(
         notification.messageText.textContent.trim(),
         notificationMessage,
         "notification message should match expectation"
       );

       let button = notification.buttonContainer.querySelector("button");
       let link = notification.supportLinkEls[0];
       if (!label) {
         ok(!button, "There should not be a button");
         ok(!link, "There should not be a link");
         return;
       }

       if (isLink) {
         ok(!button, "There should not be a button");
         is(link.textContent, label, `notification link should be '${label}'`);
         ok(
           !link.hasAttribute("accesskey"),
           "notification link should not have accesskey"
         );
       } else {
         ok(!link, "There should not be a link");
         is(
           button.getAttribute("label"),
           label,
           `notification button should be '${label}'`
         );
         is(
           button.getAttribute("accesskey"),
           accessKey,
           "notification button should have accesskey"
         );
       }

       if (!tabChecker) {
         ok(false, "Test implementation error: Missing tabChecker");
         return;
       }
       let awaitNewTab = BrowserTestUtils.waitForNewTab(gBrowser);
       if (button) {
         button.click();
       } else {
         link.click();
       }
       let openedTab = await awaitNewTab;
       tabChecker(openedTab);
       BrowserTestUtils.removeTab(openedTab);
     }
   );
 }

 if (typeof data.type === "undefined") {
   ok(false, "Test implementation error: data.type must be provided");
   return;
 }
 data.isSolved = data.isSolved || false;
 if (typeof data.decoderDoctorReportId === "undefined") {
   data.decoderDoctorReportId = "testReportId";
 }

 // Test same origin.
 await create_tab_and_test(false);
 // Test cross origin.
 await create_tab_and_test(true);
}

function tab_checker_for_sumo(expectedPath) {
 return function (openedTab) {
   let baseURL = Services.urlFormatter.formatURLPref("app.support.baseURL");
   let url = baseURL + expectedPath;
   is(
     openedTab.linkedBrowser.currentURI.spec,
     url,
     `Expected '${url}' in new tab`
   );
 };
}

function tab_checker_for_webcompat(expectedParams) {
 return function (openedTab) {
   let urlString = openedTab.linkedBrowser.currentURI.spec;
   let endpoint = Services.prefs.getStringPref(
     "media.decoder-doctor.new-issue-endpoint",
     ""
   );
   ok(
     urlString.startsWith(endpoint),
     `Expected URL starting with '${endpoint}', got '${urlString}'`
   );
   let params = new URL(urlString).searchParams;
   for (let k in expectedParams) {
     if (!params.has(k)) {
       ok(false, `Expected ${k} in webcompat URL`);
     } else {
       is(
         params.get(k),
         expectedParams[k],
         `Expected ${k}='${expectedParams[k]}' in webcompat URL`
       );
     }
   }
 };
}

add_task(async function test_platform_decoder_not_found() {
 let message = "";
 let decoderDoctorReportId = "";
 let isLinux = AppConstants.platform == "linux";
 if (isLinux) {
   message = gNavigatorBundle.getString("decoder.noCodecsLinux.message");
   decoderDoctorReportId = "MediaPlatformDecoderNotFound";
 } else if (AppConstants.platform == "win") {
   message = gNavigatorBundle.getString("decoder.noHWAcceleration.message");
   decoderDoctorReportId = "MediaWMFNeeded";
 }

 await test_decoder_doctor_notification(
   {
     type: "platform-decoder-not-found",
     decoderDoctorReportId,
     formats: "testFormat",
   },
   message,
   isLinux ? "" : { l10nId: "moz-support-link-text" },
   isLinux ? "" : gNavigatorBundle.getString("decoder.noCodecs.accesskey"),
   true,
   tab_checker_for_sumo("fix-video-audio-problems-firefox-windows")
 );
});

add_task(async function test_cannot_initialize_pulseaudio() {
 let message = "";
 // This is only sent on Linux.
 if (AppConstants.platform == "linux") {
   message = gNavigatorBundle.getString("decoder.noPulseAudio.message");
 }

 await test_decoder_doctor_notification(
   { type: "cannot-initialize-pulseaudio", formats: "testFormat" },
   message,
   { l10nId: "moz-support-link-text" },
   gNavigatorBundle.getString("decoder.noCodecs.accesskey"),
   true,
   tab_checker_for_sumo("fix-common-audio-and-video-issues")
 );
});

add_task(async function test_unsupported_libavcodec() {
 let message = "";
 // This is only sent on Linux.
 if (AppConstants.platform == "linux") {
   message = gNavigatorBundle.getString(
     "decoder.unsupportedLibavcodec.message"
   );
 }

 await test_decoder_doctor_notification(
   { type: "unsupported-libavcodec", formats: "testFormat" },
   message
 );
});

add_task(async function test_decode_error() {
 await SpecialPowers.pushPrefEnv({
   set: [
     [
       "media.decoder-doctor.new-issue-endpoint",
       "http://example.com/webcompat",
     ],
     ["browser.fixup.fallback-to-https", false],
   ],
 });
 let message = gNavigatorBundle.getString("decoder.decodeError.message");
 await test_decoder_doctor_notification(
   {
     type: "decode-error",
     decodeIssue: "DecodeIssue",
     docURL: "DocURL",
     resourceURL: "ResURL",
   },
   message,
   gNavigatorBundle.getString("decoder.decodeError.button"),
   gNavigatorBundle.getString("decoder.decodeError.accesskey"),
   false,
   tab_checker_for_webcompat({
     url: "DocURL",
     label: "type-media",
     problem_type: "video_bug",
     details: JSON.stringify({
       "Technical Information:": "DecodeIssue",
       "Resource:": "ResURL",
     }),
   })
 );
});

add_task(async function test_decode_warning() {
 await SpecialPowers.pushPrefEnv({
   set: [
     [
       "media.decoder-doctor.new-issue-endpoint",
       "http://example.com/webcompat",
     ],
   ],
 });
 let message = gNavigatorBundle.getString("decoder.decodeWarning.message");
 await test_decoder_doctor_notification(
   {
     type: "decode-warning",
     decodeIssue: "DecodeIssue",
     docURL: "DocURL",
     resourceURL: "ResURL",
   },
   message,
   gNavigatorBundle.getString("decoder.decodeError.button"),
   gNavigatorBundle.getString("decoder.decodeError.accesskey"),
   false,
   tab_checker_for_webcompat({
     url: "DocURL",
     label: "type-media",
     problem_type: "video_bug",
     details: JSON.stringify({
       "Technical Information:": "DecodeIssue",
       "Resource:": "ResURL",
     }),
   })
 );
});