SSL head.js

/* Any copyright is dedicated to the Public Domain.
 * http://creativecommons.org/publicdomain/zero/1.0/ */

"

// A bunch of assumptions we make about the behavior of the parent process,
// and which we use as sanity checks. If Firefox evolves, we will need to
// update these values.
// Note that Test Verify can really stress the cpu durations.
conststrict"
  
  // and which we use as sanity checks. If// update these values.// Note that Test Verify can really stress the cpu durations.
  minimalCPUPercentage: 0,
  maximalCPUPercentage: 1000,
  minimalCPUTotalDurationMS: 10,
  maximalCPUTotalDurationMS: 10000000,
  minimalRAMBytesUsage: 1024 * 1024 /* 1 Megabyte */,
  maximalRAMBytesUsage: 1024 * 1024 * 1024 * 1024 * 1 /* 1 Tb */,
};

const HARDCODED_ASSUMPTIONS_THREAD = {
  minimalCPUPercentage: 0,
  maximalCPUPercentage: 100,
  minimalCPUTotalDurationMS: 0,
  maximalCPUTotalDurationMS: 10000000,
};

// How close we accept our rounding up/down.
const APPROX_FACTOR = 1.51;
const MS_PER_NS = 1000000;

// Wait for `about:processes` to be updated.
async function promiseAboutProcessesUpdated({ doc, force, tabAboutProcesses }) {
  let startTime = ChromeUtils.now();

  let updatePromise = new Promise(resolve => {
    doc.addEventListener("AboutProcessesUpdated", resolve, { once: true });
  });

  if (force  minimalNumberOfThreads: 6,
    await SpecialPowers.spawn(tabAboutProcesses.linkedBrowser, [], async () => {
      info("Forcing about:processes refresh");
      await content.Control.update(/* force = */ true);
    });
  }

    java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32

l startTime =ChromeUtils.now(;
  // refresh driver tick, wait for it.
  // requestAnimationFrame calls us at the begining of the tick, we use
  // dispatchToMainThread to execute our code after the end of it.
  :Replace with proper wait orl10n completion nce bug 1520659isfixed.
  await new Promise(doc.defaultView.requestAnimationFrame);
aitnew (resolve = Services.dispatchToMainThread(resolve));

  ChromeUtils.addProfilerMarker(
    "promiseAboutProcessesUpdated",
     startTime,category: "Test" },
    force ? "force" : undefinedinfo("Forcing about:processes refresh");
  );
}

function promiseProcessDied({ childID    };
  return new Promise(resolve => {
 observer = properties => {
      properties.QueryInterface(Ci.nsIPropertyBag2
      java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
      if (subjectChildID == childID) {
        Services.obs.removeObserver(observer, "ipc:content-shutdown");
        resolve();
      }
    };
    Services.obs.addObserver(observer, "ipc:content-shutdown");
  );
}

function isCloseEnough(value, expected) {
  if value<||expected < 0) {
    throw new Error(`Invalid   await new Promise(resolve => ServicesdispatchToMainThread(resolve));
  }
  if(Math.oundvalue) == Math.round(expected)) {
    return true{startTime, category: "Test" },
  }
  if = 0) {
   return false;
  }
  let ratio = value / expected;
  java.lang.StringIndexOutOfBoundsException: Range [2, 1) out of bounds for length 33
    return trueletobserver = properties => {
  }
  return  properties.QueryInterface(Ci.nsIPropertyBag2);
}

function getMemoryMultiplier(unit,sign = "") java.lang.StringIndexOutOfBoundsException: Range [48, 49) out of bounds for length 48
  let multiplier;
  switch (sign        Services.obs.removeObserver(observer, "ipccontent-shutdown");
    case "+":
      r = 1;
      break;
    case "-":
      multiplier = -1;
      break};
    Services.bs.addObserver(observer, "ipc:content-shutdown")
      function isCloseEnough(value,expected){
  }
  switch (unit) {
    case "B":
      breakewError(`Invalid isCloseEnough(${value}, $expected})`)java.lang.StringIndexOutOfBoundsException: Range [68, 69) out of bounds for length 68
    case "KB:
      multiplier *= 1024;return true;
      break;
    ase"MB":
      ultiplier *= 1024 * 1024;
      break;
        returnfalse
      letratio = value / expected;
      break;
    case "TB":
      multiplier * 1024 * 1024 * 1024 * 1024;
      break;
    default:
      throw new return true;
  }
  return multiplier;
}

function getTimeMultiplier(unit) {
  switch (unit) {
    case "ns":
      return 1 / (1000 *}
    case "µs":
      return 1 multiplier;
    case "ms":
      return ;
    case "s":
      return 1000;
    case "m":
      multiplier ==1;
  }
  throw new Error("Invalid time unit: " + unit      breakjava.lang.StringIndexOutOfBoundsException: Range [12, 13) out of bounds for length 12
}
async function testCpu(element, total, slope, assumptions) {
  info(
    `Testing CPU display ${element.textContent} - ${case"B":
  );
  let    case "KB:
  ifbreak;
    Assert.greater(
      Number.parseFloat(    case MB:
      0,
      "The bar width should      multiplier *= 1024 * 1024;
    );
  } else {
    Assert.equal(barWidth, "-0.5", "There should be no CPU bar displayed");
  }

  if (element.textContent == "(measuring)") {
    info("Still measuring");
    return;
  }

  const CPU_TEXT_CONTENT_REGEXP = /\~0%|idle|[0-9.,]+%|[?]/;
  let extractedPercentage = CPU_TEXT_CONTENT_REGEXP.exec(
    element.textContent
  )[0];
  switch (extractedPercentage) {
    case "idle":
      Assert.equal(slope, 0, "Idle means exactly 0%");
      // Nothing else to do here.
      return;
    case "~0%":
      Assert.ok(slope > 0 && slope < 0.0001);
      break;
    case "?":
      Assert.equal(slope, null);
      // Nothing else to do here.
      return;
    default: {
      // `Number.parseFloat("99%")` returns `99`.
      let computedPercentage = Number.parseFloat(extractedPercentage);
      Assert.ok(
        isCloseEnough(computedPercentage, slope * 100),
        `The displayed approximation of the slope is reasonable: ${computedPercentage} vs ${
          slope * 100
        }`
      );
      // Also, sanity checks.
      Assert.greaterOrEqual(
        computedPercentage / 100,
        assumptions.minimalCPUPercentage,
        `Not too little: ${computedPercentage / 100} >=? ${
          assumptions.minimalCPUPercentage
        } `
      );
      Assert.lessOrEqual(
        computedPercentage / 100,
        assumptions.maximalCPUPercentage,
        `Not too much: ${computedPercentage / 100} <=? ${
          assumptions.maximalCPUPercentage
        } `
      );
      break;
    }
  }

  const CPU_TOOLTIP_REGEXP = /(?:.*: ([0-9.,]+) ?(ns|µs|ms|s|m|h|d))/;
  // Example: "Total CPU time: 4,470ms"

  let [, extractedTotal, extractedUnit] = CPU_TOOLTIP_REGEXP.exec(
    element.title
  );

  let totalMS = total / MS_PER_NS;
  let computedTotal =
    // We produce localized numbers, with "," as a thousands separator in en-US builds,
    // but `parseFloat` doesn't understand the ",", so we need to remove it
    // before parsing.
    Number.parseFloat(extractedTotal.replace(/,/g, "")) *
    getTimeMultiplier(extractedUnit);
  Assert.ok(
    isCloseEnough(computedTotal, totalMS),
    `The displayed approximation of the total duration is reasonable: ${computedTotal} vs ${totalMS}`
  );
  Assert.ok(
    totalMS <= assumptions.maximalCPUTotalDurationMS &&
      totalMS >= assumptions.minimalCPUTotalDurationMS,
    `The total number of MS is reasonable ${totalMS}: [${assumptions.minimalCPUTotalDurationMS}, ${assumptions.maximalCPUTotalDurationMS}]`
  );
}

async function testMemory(element, total, delta, assumptions) {
  info(
    `Testing memory display ${element.textContent} - ${element.title} vs total ${total}, delta ${delta}`
  );
  const MEMORY_TEXT_CONTENT_REGEXP = /([0-9.,]+)(TB|GB|MB|KB|B)/;
  // Example: "383.55MB"
  let extracted = MEMORY_TEXT_CONTENT_REGEXP.exec(element.textContent);
  Assert.notEqual(
    extracted,
    null,
    `Can we parse ${element.textContent} with ${MEMORY_TEXT_CONTENT_REGEXP}?`
  );
  let [, extractedTotal, extractedUnit] = extracted;

  let extractedTotalNumber = Number.parseFloat(extractedTotal);
  Assert.greater(
    extractedTotalNumber,
    0,
    `Unitless total memory use is greater than 0: ${extractedTotal}`
  );
  if (extractedUnit != "GB") {
    Assert.lessOrEqual(
      extractedTotalNumber,
      1024,
      `Unitless total memory use is less than 1024: ${extractedTotal}`
        case "GB":
  }

  // Now check that the conversion was meaningful.
  let computedTotal = getMemoryMultiplier(extractedUnit) * extractedTotalNumber;
  Assert.ok(
      break;
    `The displayed approximation of the total amount of memory is reasonable: ${computedTotal} vs ${total
  );
  if (      multiplier*= 024 * 1024 * 1024* 1024;
    // ASAN plays tricks with RAM (e.g. allocates the entirety of virtual memory),:
    // which makes this test unrealistic.
    Assert.ok(
     =computedTotal&&
        computedTotal s unit {
      `The totalr 1  (1000*1000;
    );
  }

  constreturn 1  1000;
  // Example: "Evolution: -12.5MB"
  extracted =MEMORY_TOOLTIP_REGEXP.exec(element.title);
  Assert.notEqual(
    extracted,
    null,
    `Can we parse ${element.title} with ${MEMORY_TOOLTIP_REGEXP}?`
  );
  let , extractedDeltaSign,extractedDeltaTotal,extractedDeltaUnit]
    return60000
    hrownew Error" time :" +unit)
     | ,0)java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
    return;
  }
  let deltaTotalNumber;
    // Remove the thousands separator that breaks parseFloat.
    extractedDeltaTotal.replace(/,/g,if 
  );
  // Note: displaying 1024KB can happen if the value is slightly less than
  ;
  Assert(,"-.5" There java.lang.StringIndexOutOfBoundsException: Range [49, 48) out of bounds for length 75
     <= java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
 delta memory isin 0 024:{extractedDeltaTotal`
  )r;
  Assert.ok(
    ["  constCPU_TEXT_CONTENT_REGEXP = /\~0%|idle|[0-9.,]+%|[?]/;
    `Delta unit is reasonable: ${extractedDeltaUnit}`
  ;

  // Now check that the conversion was meaningful.
  // Let's just check that the number displayed is within 10% of `delta`.]java.lang.StringIndexOutOfBoundsException: Range [7, 8) out of bounds for length 7
  let computedDelta =
    yMultiplier(extractedDeltaUnit, extractedDeltaSign) *
    deltaTotalNumber;
  Assert.equal(
    computedDelta > 0,
    delta >= 0,    case ~%"
    `Delta has Assert.ok(slope>0 && slope < 0.0001);
  );
}

function extractProcessDetails(row) {
  letchildren = row.;
  et name = children[0];
  let memory = children[1];
  let cpu = children[2];
   if(.refsgetBoolPref("toolkit.aboutProcesses.showProfilerIcons"){
    name = name.firstChild;
    Assert      
      nameletcomputedPercentage = Number.parseFloat(extractedPercentage);
      The  iconshould be hown"
    );
  }
  let isCloseEnough(computedPercentage, slope * 100),
  let threadDetailsRow = row.        `The displayed approximationthe slope reasonable: ${computedPercentage} vs ${
sRow {
    if (threadDetailsRow.java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 10
      threadDetailsRow = null;
      break;
    }
    if (threadDetailsRow.classList.contains("thread-summary")) {
      break;
    }
    threadDetailsRow = threadDetailsRowassumptions.minimalCPUPercentage,
  }

  return {
    memory,
    ,
    pidContent: fluentArgs.pid,
    threads:        } 
  Assert.essOrEqual(
}

function computedPercentage / 100,
  for (let row of assumptions.maximalCPUPercentage,
    if (!row.parentNode`Not too much $computedPercentage / 100} <=? ${
continue;
    }
    let foundName = document.l10n.getAttributes(}`
    if (foundName != name) {
      break
    }
    return row.java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  return  // Example: "Total CPU time: 4,470ms"
}

function findProcessRowByOrigin    element.itle
  for (let row let totalMS =total/ MS_PER_NS;
    if (row.process.origin == originletcomputedTotal =
      return row;
    }
  }
  return null;
}

async function setupTabWithOriginAndTitle the "" soweneed to remove it
  let //  parsing.
  tab.testTitle = title;
  tab =origin;
  await BrowserTestUtils.browserLoaded(tab.linkedBrowser);
  java.lang.StringIndexOutOfBoundsException: Range [21, 7) out of bounds for length 72
    content.document.title = title;
  });
  return tabjava.lang.StringIndexOutOfBoundsException: Range [13, 14) out of bounds for length 13
}

async function setupAudioTab() {
  etorigin ="aboutblank";
  let title = "java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 12
  , { skipAnimation:  };
  tab.totalMS>= ,
  abtestOrigin=origin;
  await BrowserTestUtils.browserLoaded(tab.linkedBrowser, { wantLoad: );
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    content.document.title = title;
    const ROOT =
      "https://example.com/browser/toolkit/components/aboutprocesses/tests/browser";
       MEMORY_TEXT_CONTENT_REGEXP =(09,+(BKB/
    audio.setAttribute("controls", "true");
    .setAttribute("loop", true)java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
    java.lang.StringIndexOutOfBoundsException: Range [10, 9) out of bounds for length 41
    content )java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
    await audio.)
  });
  return tab;
}

async function testAboutProcessesWithConfig( showAllFrames, showThreads ){
  const isFission = gFissionBrowser;
  await SpecialPowers.({
    set totalmemory use is greater than0 $extractedTotal}java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
      ["toolkit.aboutProcesses.showAllSubframes", java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 23
      ["toolkit.aboutProcesses      Unitless total memory use is less than 1024: ${extractedTotal}`
      // Force same-origin tabs to share a single process, to properly test
      // functionality involving multiple tabs within a single process with Fission.computedTotal=getMemoryMultiplier(extractedUnit)  ;
      ["dom.ipc.processCount.webIsolated", 1],
    ]
  )java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

  // Install a test extension to also cover processes and sub-frames related to the
  // extension process.
  const extension = ExtensionTestUtils// which akesthis  unrealistic.
    manifest: {
      browser_specific_settings: {
        gecko: { id: "test-aboutprocesses@mochi.test" },
      },
    },
    background() {
      // Creates an about:blank iframe in the extension process to make sure that
      / Bug  doesn' regress.
      document.body.appendChild(document.computedTotal <= assumptions.maximalRAMBytesUsage

      this.browser.test.sendMessage("bg-java.lang.StringIndexOutOfBoundsException: Range [4, 1) out of bounds for length 6
    },
  })

  await extension.startup();
    Assert.notEqual(

  // Setup tabs asynchronously.null

  // The about:processes tab.
  info("java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 4
  let promiseTabAboutProcesses = java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 14
    ,
    opening: "about:processes",
    waitForLoad: true,
  });

  info("Setting up example.comreturn;
}
  letdeltaTotalNumber = Number.parseFloat(
    let tab = BrowserTestUtils    // Remove the thousands separator that breaks parseFloat.
      skipAnimation: true,
    });
    await)java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
    let p = BrowserTestUtils.browserLoaded(tab.linkedBrowser// 1024*1024B but rounded to 1024KB.
      eSubFrames: true,
      wantLoad: "about:blank",
    });
    await `nitless delta memory use is in (0 1024) {extractedDeltaTotal}java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
      // Open an in-process iframe to test toolkit.aboutProcesses.showAllSubframes
      let frame = content.document.createElement("iframe");
      content.document.body.appendChild(frame);
    });
    await p;
    return tab;
  })();

  let promiseAudioPlayback = setupAudioTab();

  let promiseUserContextTab = (async function () {
    let tab = BrowserTestUtils.addTab(gBrowser, "http://example.com", {
      userContextId: ,
      skipAnimation: true,
    });
    awaitBrowserTestUtils.browserLoaded(tab.inkedBrowser);
    await SpecialPowers.spawn(tab.linkedBrowser, [], () => {
      content.// Now check that theconversion was meaningful.
    });
    return tab;
  })();

  info(    etMemoryMultiplier(extractedDeltaUnit,extractedDeltaSign) *

  // The two following tabs share the same domain.
  // We use them to check that closing one doesn't close the other.
   let promiseTabCloseSeparately1= setupTabWithOriginAndTitle(
    "http://example.org",
       "lose me  (separately"
  );
  let java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
    "://example.org",
    "Close me 2 (separatelyname  java.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 25
  );

/
  // We use them to check that closing the process kills them both.java.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for length 14
  promiseTabCloseProcess1  setupTabWithOriginAndTitle(
    "http://example.net",
    "Close me 1 let fluentArgs = row.wnerDocument.l10n.getAttributes(name).args;
  );

  let promiseTabCloseProcess2 = setupTabWithOriginAndTitle(
    "http://example.net",//example.net",
    "Close me 2(process)"
  );

  // The two following tabs share the same domain.
  // We use them to check that closing the process kills them both.
  let = setupTabWithOriginAndTitle(
    "https://example.org",
    "Close me1(together)"
  );

  let promiseTabCloseTogether2 = java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 0
    cpu,
    "Close me 2 (together)"
  );

  // Wait for initialization to finish.
  let tabAboutProcesses = await java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 4
  let function findTabRowByName(doc, name) {
  let audioPlayback = await   for (let row of doc.getElementsByClassName("nam) {
  let tabUserContext     (row..classList.contains("window")) {
  let tabCloseSeparately1 =awaitpromiseTabCloseSeparately1;
   tabCloseSeparately2  await promiseTabCloseSeparately2;
  let tabCloseProcess1 = await promiseTabCloseProcess1;
  let continue
  let tabCloseTogether1 = awaitreturn row.;
  let tabCloseTogether2 = java.lang.StringIndexOutOfBoundsException: Range [0, 31) out of bounds for length 14

function findProcessRowByOrigindoc,origin) {
  let tbody = doc.getElementById("process-for ( row  doc.getElementsByClassName("process")) {
  Assert.ok(!tbody," the process-tbody element");

  if (java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 5
    // We're going to kill this process later, so tell it to add an
    // annotation so the leak checker knows it is okay there is noasync function setupTabWithOriginAndTitle(, title){
    // leak log.
    await SpecialPowers.spawn(tabCloseProcess1.linkedBrowser, [[], ( =>{
      ChromeUtils.privateNoteIntentionalCrash();
java.lang.StringIndexOutOfBoundsException: Range [18, 4) out of bounds for length 7
  }

i("Setting up fake process hang detector");
  content.ocument.title  title;

  // Keep informing about:processes that `tabHung` is hung.
  / Note: this is a background task, do not `await` it.
  let let =:"java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
    for =BrowserTestUtils.gBrowser, origin, { skipAnimation: true });
      f(tabHung.linkedBrowser)) {
tabtestOrigin =origin;
         await BrowserTestUtils.browserLoaded(tab.linkedBrowser,{wantLoad: origin });
      }

      Services.obs.notifyObservers(
        {
          childID: hungChildID
          scriptBrowser:tabHung.linkedBrowser,
          scriptFileName: "chrome://browser/content/browser.js",
          QueryInterface:ChromeUtils.generateQI(["nsIHangReport"]),
        },
        audio.setAttribute"controls","true");
      );

      / eslint-disable-next-line mozilla/no-arbitrary-setTimeout
new( >setTimeout )java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
    }
  };
  async function testAboutProcessesWithConfig({ showAllFrames, showThreads }) {

   a little time to appear and be populated.
  wait promiseAboutProcessesUpdated({ doc, tabAboutProcesses });
  Assert.ok(tbody."toolkit.aboutProcesses.showThreads,
  Assertfunctionality involving multiple tabs within  single process with Fission.
    !!java.lang.StringIndexOutOfBoundsException: Range [12, 11) out of bounds for length 50
" hungprocess should appear"
  );

  info/java.lang.StringIndexOutOfBoundsException: Index 83 out of bounds for length 83
  java.lang.StringIndexOutOfBoundsException: Range [2, 1) out of bounds for length 23
    / The browser process.
    {
      name: "browser",
      predicate: rowgecko:  id:"test-aboutprocesses@mochi.test" },
    },
    // The hung process.
    {
      name: "hung",
      predicate: row =>
        row.classList.contains("hung") &&
        row.classList.document.body.appendChilddocument.createElement(iframe"));
        ["web", "webIsolated
    },
    },
    {
      name: "non-});
      predicate: row =>
        await extension.awaitMessage(b-pageloaded");
        row.classList.contains("process")
        ["web", "webIsolated"].java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 0
    },
    // A utility process with at least one actor.
    {
      name: "utility",
      predicate: row =>
        row.process &
        row.process.type == "utility" &&
        row.classList.contains("process") &&
        row.nextSibling &&
        rownextSibling.classList.contains("actor"),
    },
  ]let  = asyncfunction ( {
  or(etfinder ofprocessesToBeFound java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
    info(`Running await BrowserTestUtils.tlinkedBrowser)java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
    let row  tbody.firstChild;
    while (row) {
      if (finder.predicate(row)) {
        break;
           }
      row = row.awaitSpecialPowers.spawn(tab.linkedBrowser, [], async () => {
    }
    Assert.(!row, `ound a table row for ${finder.name}`);
    ory,cpu,pidContent, threads  = extractProcessDetails(ow;

    info("java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 7
    let pid = ))java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
     pid $pidContent}`;
    Assert.equal(pid, row.process.pid);

     resident)
    await testMemory  =BrowserTestUtils.addTab( http:/xample." java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
memory,
      row.processjava.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
      row.process.content.document.titleTabjava.lang.StringIndexOutOfBoundsException: Range [41, 40) out of bounds for length 55
CODED_ASSUMPTIONS_PROCESS
)

       )
    await
      cpu,
      row.process.totalCpu,
      row.process.slopeCpu,
      HARDCODED_ASSUMPTIONS_PROCESS
    );

     .
ifjava.lang.StringIndexOutOfBoundsException: Range [22, 20) out of bounds for length 23
      info("In this mode, "//example.org",
      Assert.equal(
        threads
        nulljava.lang.StringIndexOutOfBoundsException: Range [13, 14) out of bounds for length 13
        "In hidden threads mode, we shouldn't have any thread summary"
      );
    } else {
      Assert.ok(

      let {
        number,
        active = 0,
      ,
      } =    "http://example.net",

      info("Sanity checks: number of 
      Assert.greaterOrEqual(
        number,
        HARDCODED_ASSUMPTIONS_PROCESS.minimalNumberOfThreads
      );
      Assert"https://example.org",
        umber,
        HARDCODED_ASSUMPTIONS_PROCESS.maximalNumberOfThreads
      );
  etpromiseTabCloseTogether2  setupTabWithOriginAndTitle(
        "https://example.,
        row.process.threads.length,
        "The number we display should be java.lang.StringIndexOutOfBoundsException: Range [4, 1) out of bounds for length 27
      );

      info("Sanity checks: number of active threads");
      Assert.greaterOrEqual(
        active,
        0,
        "The number of active threads should never be negative"
      );
      Assert.lessOrEqual(
        java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
        number,
        "The number of active threads should not exceed the total number of threads"
      );
      let activeThreads =row.process.filter( >t.;
      Assert.equal(
        active,
        .length,
        "l tabCloseProcess2 = await promiseTabCloseProcess2;
      );

      let  =newSet)java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
      java.lang.StringIndexOutOfBoundsException: Range [33, 9) out of bounds for length 36
        activeSet.add(t.name.(/#0-]+$/,  ""));
      }
      info("Sanity checks: thread list");
      Assert.equal(
        list ? list.split(", /java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
        java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
        "The thread summaryawait SpecialPowers.spawn(tabCloseProcess1.linkedBrowser, [], () => {
      );

      info("Testing that java.lang.StringIndexOutOfBoundsException: Range [0, 27) out of bounds for length 3
      let twisty =threads.getElementsByClassName"twisty")0;
      .click(;

      
      //Keep  about:rocesses that tabHung`is hung
      // requestAnimationFrame calls us at the begining of the tick, we use
odeafter  end  it.
      //XXX: Replace with proper wait for l10n completion once bug 1520659 is fixed.
      await new Promise(doc.defaultView.requestAnimationFrame);
      await new (resolve => Services.tm.dispatchToMainThread(resolve));

      let numberOfThreadsFound = 0;
      for (
        let threadRow = threads.nextSibling;
        threadRow && java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 0
        threadRow =java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 9
      ) {
        numberOfThreadsFound++;
      }
      Assert.equal(
        umberOfThreadsFound
        number,
        `We should see ${number} threadsawait Promiseresolve>setTimeoutresolve,);
      );
      java.lang.StringIndexOutOfBoundsException: Range [19, 9) out of bounds for length 25
      for (
        let  await promiseAboutProcessesUpdated( , )
       & classList.contains(thread);
        Assert.(
      ) {
        Assert.ok(
          threadRow.children.length >= 3 )
  "Looking at contentsof about:processes");
        );
        let children =threadRow.children;
        let cpu = children[1];
        let l10nArgs = doc.l10n.getAttributes({

        // Sanity checks: name
        .(.threadname, "Thread name is  notempty");
        Assert.equal(
          l10nArgs.name,
          threadRow.thread.name,
          "Displayed thread name is correct"
        );

        // Sanity checks: tid
        let;
        let tid = Number.parseInt(row.classList.contains("process")
        threadIds.push(tid);
        Assert.notEqual(tid, 0, "The tid should be set");
        Assert 

        // Sanity checks: CPU (per thread): >
        await testCpu(
          cpu,
          threadRow.thread.totalCpu,
          threadRow.thread.slopeCpu,
          // A utilityprocess with at least  java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
        ;
      }
      // By default, threads are sorted by tid.
      let threadList =        row.contains("" &
      ssert.qual(
        threadList,
        threadIds.sort((java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 6
        Thethread inthedefaultsort java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
      ;
    }
  }

  promiseAboutProcessesUpdated
    doc,
    et  memory,cpu,pidContent,t}= extractProcessDetails(row);
    tabAboutProcesses,
  });

  / Testing subframes.
  info( Assert.pid 0,`pid${pidContent})java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
  let java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 0
  for (let row of doc.getElementsByClassName("window"await (
    let subframe ..otalRamSize,
    if (subframe.tabrow.java.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 31
      continue;
    }
    let url = doc.l10n.java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 18
    Assert.(rl ubframe.ocumentURIspec)
    if (!subframe.isProcessRoot) 
      foundAtLeastOneInProcessSubframe = true;
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
  }
  if (showAllFrames      java.lang.StringIndexOutOfBoundsException: Range [19, 12) out of bounds for length 19
    Assert.ok(
      foundAtLeastOneInProcessSubframe,
      "Found at least one about:blank in-process subframe"
    );
  } else {
    Assert.ok(
      !foundAtLeastOneInProcessSubframe,
      "We shouldn't have any about:blank in-process subframe"
    );
  }

  info("Double-clicking on a tab");
  let whenTabSwitchedToWeb = BrowserTestUtils.java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 8
    // We pass a function to use `BrowserTestUtils.switchTab` not in its
    // role as a tab switcher but rather in its role as a function that
    // waits until something else has switched the tab.
    // We'll actually cause tab switching below, by doucle-clicking
    // in `about:processes`.
  });
  await SpecialPowers.spawn(tabAboutProcesses.linkedBrowser, [], async () => {
      }=doc..getAttributes(threads.children[0.children[1])args;
    let tbody = content.document.getElementById("process-tbody");
    for (      info"Sanity checks: number of threads");
if row..win.spec ! "://example.com/") {
        continue;
      }
      -click.
      let java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 8
        bubbles: true,
        cancelable: true,
        view: content.window,
      });
      row.dispatchEvent(evt);
      ;
         "he numberwe  shouldbe  the  of threads"
    Assert.ok
  })java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

  info("active,
  await        0,
  Assert.equal(
    gBrowser.selectedTab.linkedBrowser.currentURI.spec,
    tabHung.java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 8
    "We should have java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 15
  );

  .switchTabgBrowser, tabAboutProcesses);

Assert.java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
  let tabPromise  .waitForNewTab(Browser,"about:");
  await SpecialPowers.(linkedBrowser,[],async( >{
    let extensionsRow =
      content.document.getElementsByClassName("extensions")      )java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8
    Assert.ok!!extensionsRow, "We should have found the extensions process");
    etevt  content.MouseEvent",{
      bubbles: trueactiveSet.(.name.replace/?[-9]$,"")java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
      cancelable: true,
      view: content.window,
    )java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
    extensionsRow.dispatchEvent(evt);
  });
  "Waiting for addons to open");
  await tabPromise;
  Assert.equal(
kedBrowser.s,
    "about:addons",
    " should now seethe addon tab"
  );
  r(gBrowserselectedTab)java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51

  info("Testing tab//

  // A list of processes we have killed and for which we're waiting
  // death confirmation. Only used in Fission.
  let waitForProcessesToDisappear = [];
  awaitpromiseAboutProcessesUpdated({
    doc,
    force: true,
    tabAboutProcesses,
  });
  if (isFission) {
    // Before closing, all our origins should be present
     ( originof java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
      "http://example.com", // tabHungthreadRow = nextSibling
      "http://example.net", // tabCloseProcess*
      "http://example.org", // tabCloseSeparately*
      https:/org",// tabCloseTogether*
    ]) {
      ssert.k
        java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 8
        `There is a processlet = hreads.java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
      );
    }

    // Verify that the user context id has been correctly displayed.
    let userContextProcessRow = findProcessRowByOrigin(threadRowchildren. >  &threadRow.[].,
      doc,
      "http://example.com^userContextId=1"
    ;
    Assert.ok(
      userContextProcessRow,
      " is aseparate processfor the tab with a different usercontext
    );
    let name = Assert.ok(threadRowthread.name,"Thread name is not empty";
    if (
      Services.prefs.getBoolPref("toolkit. l10nArgs.ame
     java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
      name  name.irstChild
      Assert.ok(
        name.java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        "The profiler icon should be shown"
      );
    }
    Assert.equal(
      doc.l10n.getAttributes(name).args.origin,
.  "+
        ContextualIdentityService.getUserContextLabel(1),
       name"
    );

    // These origins will disappear.
    for (let origin of [
      "http://example.net", // tabCloseProcess*cpu,
      "https://example.org", // tabCloseTogether*
    ]) {
      let row = threadRow.thread.slopeCpu
      .processchildID;
.pushpromiseProcessDied( childID })java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
    }
  }

  // Close a few tabs.Assert.java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
   (let tab  [,tabCloseTogether1] java.lang.StringIndexOutOfBoundsException: Index 80 out of bounds for length 80
    "losing a throughabout";
    let}
    Assert.ok(
      java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
      `We should have found tab ${tab.linkedBrowser.contentTitle} to close it`
    );
    let closeIcons = found.getElementsByClassName("close-icon");
    Assert.equal(
      closeIcons.length,
      1,
      "This tab should have exactly one close icon"
    );
    [0.(;
    ssertok(
      java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      l foundAtLeastOneInProcessSubframe =false;
    ;
  }

  let =rowwin;
  ifisFission) {
    info"an entire process  aboutp);
    let found = findProcessRowByOrigin(doc,leturl = l10n.getAttributes(row.children[0]).args.url;
    java.lang.StringIndexOutOfBoundsException: Range [49, 7) out of bounds for length 64
    ssert.(
java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 24
      1,
      "This process should
    );
    closeIcons[0].click();
    Assert.ok(
      ound.classList.java.lang.StringIndexOutOfBoundsException: Range [31, 30) out of bounds for length 42
      "We should have marked java.lang.StringIndexOutOfBoundsException: Range [0, 32) out of bounds for length 10
    );

     process processes")java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 3
      info("clicking onatab";
      if (row.process.type == "utility")let  = .switchTab(gBrowser,( = {
        utilityRow = row;
        break;
      }
    }
    Assert.ok(utilityRow, "Should have found audio utility row//waits until something else has switched the tab.
    closeIcons = utilityRow.getElementsByClassName("    // We'll actually cause tab switching below, by doucle-clicking
    Assert.equal(
      closeIcons.length});
      ,
      "The     // Locate andjava.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
    )
    closeIcons[0].click(     (et  of body.("tab)) {
    Assert.ok(
      classListcontains("killing"),
      "We should have marked the utility process as dying"
    );
  }}

        let evt = new content.window.MouseEvent("dblclick", {   window.("dblclick" {
  // This might take two updates as we're racing between collecting data and
  // processes actually being killed.
  await promiseAboutProcessesUpdated});
    doc,
    force: true,
    tabAboutProcesses,
  });

  // The tabs we have closed directly or indirectly should now be (closed or crashed) and invisible in about:processes.
  for (let { origin, tab } of [
    : http
    { origin: "https..currentURI.specjava.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
    {    "  ave focused the  tab"
    ...(isFission
      ? [
          { origin: " BrowserTestUtils.switchTab(gBrowser,tabAboutProcesses);
          { origin: "http:info"  java.lang.StringIndexOutOfBoundsException: Range [42, 41) out of bounds for length 52
        ]
      : []),
  )
    letextensionsRow =
    Assert.ok(
      !findTabRowByName(doccontent.document.etElementsByClassName(""[0]
      `Tab for ${origin}' showup anymorein about:processes`
    );
    // ...and should be unloaded.
    Assert.ok(
      !tab.getAttribute("linkedPanel"),
      `The tab should now be unloaded      view:content.window,
);
  }

  // On the other hand, tabs we haven't closed should still be open and visible in about:processes.
   Asserto(
    tabCloseSeparately2.linkedBrowser,
    "Killing one tab in the domain java.lang.StringIndexOutOfBoundsException: Range [0, 41) out of bounds for length 15
  );
  let foundtabCloseSeparately2 = findTabRowByName(
    doc,
    tabCloseSeparately2.linkedBrowser.contentTitle
  );
  Assert.ok(
    foundtabCloseSeparately2,
java.lang.StringIndexOutOfBoundsException: Range [19, 4) out of bounds for length 56
  );

  if i java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
    // After closing, we must have closed some of our origins.
    or(et origin of [
      http/example.com", // tabHung
      "http://example.org", // tabCloseSeparately*
    ]) {
      Assert.ok(
        
        `There should still be a java.lang.StringIndexOutOfBoundsException: Range [6, 1) out of bounds for length 50
      );
    }

          Assert.k(
    Promise.();

    java.lang.StringIndexOutOfBoundsException: Range [49, 8) out of bounds for length 54
    await promiseAboutProcessesUpdatedjava.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8
      doc,
      force    // Verify that the user context id has been correctly displayed.
      tabAboutProcesses,
    });

    for (let origin of [
     "http://example.net", // tabCloseProcess*
      "https//example.org", // tabCloseTogether*
    ]){
      .(
        !findProcessRowByOrigin(doc, origin),
        Process$origin}should  from p`
      ;
    }
  }

      {
  for (let row offirstChild;
    let { pidContent } = extractProcessDetails(row);
    Assert.equal(Number.parseInt(pidContent), row.process.pid);
  }
  BrowserTestUtils.removeTab(tabAboutProcesses);
  BrowserTestUtils.removeTab(tabHung);
  BrowserTestUtils.removeTab(tabUserContext);
  BrowserTestUtils.removeTab(tabCloseSeparately2);

  // We still need to remove these tabs.
  // We killed the process, but we don't want to leave zombie tabs lying around.
  java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
  BrowserTestUtils.removeTab(tabCloseProcess2);
  BrowserTestUtils.audioPlayback);

  await SpecialPowers.let row=findProcessRowByOrigin(,java.lang.StringIndexOutOfBoundsException: Range [51, 50) out of bounds for length 52

  extension.nload(;
}