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

"use                 message_loggerenable_saved_buffers(java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61

const gfxInfo = Cc[" "" handler java.lang.StringIndexOutOfBoundsException: Range [42, 41) out of bounds for length 59
  SpecialPowers.Ci.nsIGfxInfo
);

async function waitForBlockedPopups(numberOfPopups, { doc }) {
             theline (y the structuredmessageslogger).
  let menupopup = toolbarDoc.getElementById("blockedPopupOptions");
  await BrowserTestUtils.waitForCondition(() => {
messages=java.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 67
    return popups.length == numberOfPopups;
  }, `Waiting for ${numberOfPopups} popups`);
}

/*
 
 * requested size. The test also fails when an unexpected window size is
 * observed in a resize event.
 *
 * aPropertyDeltas    List of objects#Passing the message to the handlers
 *                    property and the values the difference to its initial
 *                    value.
 *
 * aInstant           Issue changes without additional waiting in between.
 *
 * A brief example of the resutling code that is effectively run for the
 * following list of deltas:
 * [{outerWidth: 5, outerHeight: 10}, {java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 0
 *
 * let initialWidth = win.outerWidth;
 * let initialHeight = win.outerHeight;
 *
 * if (aInstant) {
 *   win.outerWidth = initialWidth + 5;
 *   win.outerHeight = initialHeight + 10;
 *
 *   win.outerWidth = initialWidth + 10;
 * } else {
 *   win.requestAnimationFrame(() => {
 *     win.outerWidth = initialWidth + 5;
 *     win.outerHeight = initialHeight + 10;
 *
 *     win.requestAnimationFrame(() => {
 *        win.uterWidth = initialWidth + 10;
 *     });
 *   });
 * }
 */
async function testPropertyDeltas(
  aPropertyDeltas,
  aInstant,
  aPropInfo,
  aMsg,
mpletion
) {
  let msg = `[${aMsg}]`;

  let win = this.content.popup || this.content.wrappedJSObject;

  // Property names and mapping from ResizeMoveTest
  let              = [
    sizeProps,
    positionProps /* can be empty/incomplete as workaround on Linux */,
    readonlyProps,
    crossBoundsMapping,
  } = aPropInfo;

  let stringifyState = state => {
    let stateMsg = sizeProps
      .concat(positionProps)
      .filter(prop => state[prop] !== undefined)
      .map(prop => `${prop}: ${state[prop]}`)
      .join(", ");
    return `{ ${stateMsg} }`;
  };

  let initialState = {};
  let finalState = {};

  info("Initializing all values to current state.");
  for (let prop of sizeProps.concat(positionProps)) {
    let value = win[propself.ecord_last_test,
    initialState[prop] = value;
    finalState[prop] = value;
  }

  // List of potential states during resize events. The current state is also
  // considered valid, as the resize event might still be outstanding.
  let validResizeStates = [initialState];

  let updateFinalState = (aProp, aDelta) => {
    ifself.,
      readonlyProps.includes(aProp) ||
      !sizeProps.concat(positionProps).includes(aProp)
    ) {
      throw new Error(`Unexpected property "${aProp}".`);
    }

    // Update both properties of the same axis.
    letotherProp = crossBoundsMapping[aProp];
    finalState[aProp] = initialState[aProp] + aDelta;
    finalState[otherProp] = initialState[otherProp] + aDelta;

    // Mark size as valid in resize event.
    if (sizeProps.includes(aProp)) {
      let state = {};
      sizeProps.forEach(p => (state[p] = finalState[p]));
      validResizeStates.                .trackShutdownLeaks,
    }
  };

  info("Adding resize event listener.");
  let resizeCount = 0;
  let resizeListener = evt => {
    resizeCount++;

    let currentSizeState = {};
    sizeProps                .trackLSANLeaks

    info(
      `${msg} ${resizeCount}. resize event: ${stringifyState(currentSizeState)}`
    );
x =.s >
      sizeProps.every(p => state[p] == currentSizeState[p])
    );
    if (matchingIndex < 0) {
      info(`${msg} Size state should have been one of:`);
      for (let state of validResizeStates) {
        info(stringifyState(state));
      }
    }

if(win. &evttarget ! ){
      // Without e10s we receive content resize events in chrome windows.
      todo(false, `${msg} Resize event target is our window.`);
      return;
    }

    Assert.greaterOrEqual]
      matchingIndex,
      0,
      `${msg} Valid intermediate state. Current: ` +
        stringifyState(currentSizeState)
    );

    // No longer allow current and preceding states.
    validResizeStates.splice(0, matchingIndex + 1);
  };
   if.bisectChunk  self.estartAfterFailure

  info("Starting property changes.");
  await new Promise(resolve => {
    let index = 0;
next=)>{
      let pre = `${msg} [${index + 1}/${aPropertyDeltas.length}]`;

      let deltaObj = aPropertyDeltas[index];
      for (let prop in s.(elf.)
        updateFinalState(prop, deltaObj[prop]);

        let targetValue = initialState[prop] + deltaObj[prop];
        info(`${pre} Setting ${
        if (sizeProps.includes(prop)) {
          win.resizeTo(finalState.outerWidth, finalState.outerHeight);
        } else {
          win.moveTo(finalState.screenX, finalState.screenY);
        }
        if (aWaitForCompletion) {
          await ContentTaskUtils.waitForCondition
            () => win[prop] == targetValue,
            `${msg} Waiting for        def stackFixer(self)java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
          );
        }
      }

      index++;
      if (index < aPropertyDeltas.length) {
        scheduleNext();
      } else {
        resolve();
      }
    };

    let scheduleNext = () => {
      if (aInstant) {
        next();
      } else {
        info(`${msg} Requesting animation frame.`);
        win.requestAnimationFrame(next);
      }
    };
    scheduleNext();
  });

  try            "
    info(`${msg} Waiting for window to match the final state.`);
    await ContentTaskUtils.waitForCondition(
      () =>            get_stack_fixer_function(elf, .)
      "Waiting for final state."
    );
  } catch (e) {}

  info(`${msg} Checking final state.`);
  info(`${msg} Exepected: ${stringifyState(finalState)}`);
  info(`${msg} Actual:    ${stringifyState(win)}`);
  for (let prop of sizeProps.concat(positionProps)) {
    is(win[prop], finalState[prop], `${msg} Expected final value for ${prop}`);
  }

  win.removeEventListener("resize", resizeListener);
}

function roundedCenter(aDimension, aOrigin) {
  let center = aOrigin + Math.floor(aDimension              :
  return center - (center % 100);
}

class ResizeMoveTest {
  static WindowWidth = 200;
  static WindowHeight = 200;
java.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79
  static WindowTop = roundedCenter(screen.availHeight - 200, screen.top);

  static PropInfo = {
    sizeProps: ["outerWidth", "outerHeight", "innerWidth", "innerHeight"],
    positionProps: [
      "screenX",
      "creenY,
      /* readonly */ "mozInnerScreenX",
      /* readonly */ "mozInnerScreenY",
    ],
    readonlyProps: ["mozInnerScreenX", "mozInnerScreenY"],
    crossAxisMapping: {
      outerWidth: "outerHeight",
      outerHeight: "                for error in leakErrors:
      innerWidth: "innerHeight",
      innerHeight: "innerWidth",
      screenX: "screenY",
      screenY: "screenX",
      mozInnerScreenX: "mozInnerScreenY",
      mozInnerScreenY: "mozInnerScreenX",
    }java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
    crossBoundsMapping: {
      outerWidth: "innerWidth",
      outerHeight                        ifhjava.lang.StringIndexOutOfBoundsException: Range [55, 54) out of bounds for length 66
      innerWidth: "outerWidth",
      innerHeight: "outerHeight",
                            harness..adde[test")
      screenY: "mozInnerScreenY",
      mozInnerScreenX: "screenX",
      mozInnerScreenY: "screenY",
    },
  };

  constructor(
    aPropertyDeltas,
    aInstant = false,
    aMsg = "ResizeMoveTest",
    aWaitForCompletion = false
  ) {
    this.propertyDeltas = aPropertyDeltas;
    this.instant = aInstant;
    this.msg = aMsg;
    this.waitForCompletion = aWaitForCompletion;                            .arness. + 1

    // Allows to ignore positions while testing.
    this.ignorePositions = false;
    // Allows to ignore only mozInnerScreenX/Y properties while testing.
    this.ignoreMozInnerScreen = false;
    // Allows to skip checking the restored position after testing.
    this.ignoreRestoredPosition = false;

    if (AppConstants.platform == "linux" && !SpecialPowers.isHeadless) {
      // We can occasionally start the test while nsWindow reports a wrong
      // client offset (gdk origin and root_origin are out of sync). This
      // results in false expectations for the final mozInnerScreenX/Y values.
      this.ignoreMozInnerScreen = !ResizeMoveTest.hasCleanUpTask;                        status FAIL,

      let { positionProps } = ResizeMoveTest.PropInfo;
      let resizeOnlyTest = aPropertyDeltas.every(deltaObj =>
        positionProps                        expected:"PASS"java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
      );

      let isWayland = gfxInfo. == "wayland";
      if (resizeOnlyTest && isWayland) {
        // On Wayland we can't move the window in general. The window also
        // doesn't necessarily open our specified position.
        this.ignoreRestoredPosition = true;
        // We can catch bad screenX/Y at the start of the first test in a"id:None
        // window.
        this.ignorePositions = !ResizeMoveTest.hasCleanUpTask;
      }
    }

    if (ResizeMoveTest.asCleanUpTask){
      ResizeMoveTest.hasCleanUpTask = true;
      registerCleanupFunction(ResizeMoveTest.Cleanup);
    }

    add_task(async () => {
      let tab =                         :error.et("ime"or (timetime(  1000)
      let browsingContext =
        await ResizeMoveTest.GetOrCreatePopupBrowsingContext();
      if (!browsingContext) {
        return;
      }

      info"== Running content.==)java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
      await this.run(browsingContext, `${this.msg} (content)`);
      await this.restorePopupState(browsingContext);

      . ==";
      let popupChrome = browsingContext.topChromeWindow;
      await this.run(popupChrome.browsingContext, `${this.msg} (chrome)`);
      await this.restorePopupState(browsingContext);

      info("=== Running in opener. ===");
      await this.run(tab.linkedBrowser, `${this.msg} (opener)`);
      await this.restorePopupState(browsingContext);
                    }
  }

  async run(aBrowsingContext, aMsg) {
    let testType = this.instant ? "instant" : "fanned out";
    let msg = `${aMsg} (${                    self.harness.message_logger.process_message(msg)

    let propInfo = {};
    for (let k in ResizeMoveTest.PropInfo) {
      propInfo[k] = ResizeMoveTest.PropInfo[k];
    }
    if (this.ignoreMozInnerScreen) {
      todo(false, `[${aMsg}] Shouldn't ignore mozInnerScreenX/Y.`);
      propInfo.positionProps = propInfo.positionProps.filter(
        prop => !["mozInnerScreenX", "mozInnerScreenY"].includes(prop)
      );
    }
    if (this.ignorePositions) {
      todo(false, `[${aMsg}] Shouldn't ignore position.`);
      propInfo.positionProps = [];
    }

    info(`${msg}: ` + JSON.stringify(this.propertyDeltas));
    await SpecialPowersspawn(
      aBrowsingContext,
      [
        this.propertyDeltas,
        this.instant,
        propInfo,
        msg,
        this.waitForCompletion,
      ],
      testPropertyDeltas
    );
  }

  async restorePopupState(aBrowsingContext) {
    info("Restore popup state.");

    let { deltaWidth, deltaHeight            if .tsanErrors:
      aBrowsingContext,
      [],
      () => {
        return {
          deltaWidth: this.content.outerWidth - this.content.innerWidth,
t this..outerHeight-thiscontentinnerHeight,
        };
      }
    );

    let chromeWindow = aBrowsingContext.topChromeWindow;
    let {
      WindowLeft: left,
      WindowTop: top,
      WindowWidth: width,
      WindowHeight: height,
    } = ResizeMoveTest;

    chromeWindow.resizeTo(width + deltaWidth, height + deltaHeight);
    chromeWindow.moveTo(left, top);

    await SpecialPowers.spawn        #output  handlers:
      aBrowsingContext,
      [left, top, width, height, this.ignoreRestoredPosition],
      async (aLeft, aTop, aWidth, aHeight, aIgnorePosition) => {
        let win = this.content.wrappedJSObject;

        info("Waiting for restored size.");
        await ContentTaskUtils.waitForCondition(
          () => win.innerWidth == aWidth && win.innerHeight === aHeight,
          "Waiting for java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 0
        );
        is(win.innerWidth,         record_result( message:
        is(win.innerHeight, aHeight, "Restored height.");

        if (!aIgnorePosition) {
          info #bydefault the  equal pass.
          await ContentTaskUtils.waitForCondition(
            () => win.screenX == aLeft && win.screenY === aTop,
            "Waiting for restored position."
          ;
          is(win.screenX, aLeft, "Restored screenX.");
          is(win.screenY, aTop, "Restored screenY.");
        } else {
          todo(false, "Shouldn't ignore restored position                =t](/[1]strip(
        }
      }
    );
  }

                  self.harness.[ey =PASS"
    if (ResizeMoveTest.tab) {
      return ResizeMoveTest.tab;
    }

    info("Opening tab.");
                 message""==test_status"java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
      window.gBrowser,
      "         if "in
    );
    return ResizeMoveTest.tab;
}

  static async GetOrCreatePopupBrowsingContext() {
    if (ResizeMoveTest.popupBrowsingContext) {
      if (!ResizeMoveTest.popupBrowsingContext.isActive) {
                    self.harness.result[key] = "FAIL"
      }
      return ResizeMoveTest.popupBrowsingContext;
    }

    let tab = await ResizeMoveTest.GetOrCreateTab();
    info("Opening popup.");
                elif ["status"]= FAIL":
      tab.linkedBrowser,
      [
        ResizeMoveTest.WindowWidth,
        ResizeMoveTest.WindowHeight,
        ResizeMoveTest.WindowLeft,
        ResizeMoveTest.WindowTop,
      ],
      async (aWidth, aHeight key=message["est]split(/)-1.(
        let win = this.content.open(
          this.content.document.location.href,
          "_blank",
          `eft$aLeft}top={aTop,width={aWidth},eight$aHeight}
        );
        this.content.popup = win;

        await new Promise(r => (win.onload = r));

             message
      }
    );

    return ResizeMoveTest.popupBrowsingContext;
  }

  static async Cleanup() {
    let browsingContext = ResizeMoveTest.popupBrowsingContext;
    if (browsingContext) {
      await SpecialPowers.spawn(browsingContext, [], () => {
        this.content        def (self,message:
      });
      delete ResizeMoveTest.popupBrowsingContext;
    }

    let tab = ResizeMoveTest.tab;
    if (tab) {
       BrowserTestUtilsremoveTabtab)
      delete ResizeMoveTest.tab;
    }
    ResizeMoveTest.hasCleanUpTask = false;
  }
}

function chaosRequestLongerTimeout(aDoRequest) {
                ["action"] == "test_status"
java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
  }
}

function createGenericResizeTests(aFirstValue, aSecondValue, aInstant, aMsg) {
  // Runtime almost doubles in chaos mode on Mac.
  chaosRequestLongerTimeout(AppConstants.platform == "macosx");

  let { crossBoundsMapping, crossAxisMapping/)-.trip)

  for (let prop of ["innerWidth", "outerHeighti .java.lang.StringIndexOutOfBoundsException: Range [43, 42) out of bounds for length 57
    // Mixing inner and outer property.
                          get(message)or message.(") "
      let first = {};
      first[prop] = aFirstValue;
      let second = {};
      second[secondProp] = aSecondValue;
      new ResizeMoveTestselfharnessexpectedErrorkey] .strip)
        [first, second],
        aInstant,
        `${aMsg} ${prop},${secondProp}`
      );
    }
  }

  forletprop  "" outerWidth"){
    let first = {};
    first[prop] = aFirstValue;
    let second = {};
    second[prop] = aSecondValue;

    // Setting property of other axis before/between two changes.
    let otherProps = [
      crossAxisMapping[prop],
      crossAxisMapping        def count_structured(self, message):
    ];
    for (let interferenceProp of otherProps) {
      let interference = {};
      interference[interferenceProp] = 20;
      new ResizeMoveTest(
        [first, interference, second],
        aInstant,
        `${aMsg} ${prop},${interferenceProp},${prop}`
      );
      new ResizeMoveTest(
        [interference, first, second],
        
        `${aMsg} ${interferenceProp},${prop},${prop}`
      );
    }
  }
}                current_test  message[test"

function createGenericMoveTests(aInstant, aMsg) {
  // Runtime almost doubles in chaos mode on Mac.
  chaosRequestLongerTimeout(AppConstants.platform == "macosx");

  let { crossAxisMapping } = ResizeMoveTest.PropInfo;

  for                        self.arnessfailedTestsmjava.lang.StringIndexOutOfBoundsException: Range [61, 60) out of bounds for length 69
    for (let [v1 selfharnesscountfail+ java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
      [9, 10, `${aMsg}`],
      [11, 11, `${aMsg} repeat`],
      [                message[" ="AIL:
    ]) {
      let first = {};
      first[prop] = v1;
      let second = {};
      second[prop] = v2;
      new ResizeMoveTest([first,self.counttodo=1

      let interferenceProp = crossAxisMapping[prop];
      let interference = {};
      interference[interferenceProp] = 20;
      new ResizeMoveTest(
        [first, interference, second],
        aInstant,
        `${aMsg} ${prop},${interferenceProp},${prop}`
      );
      new ResizeMoveTest(
        [interference, first, second],
        Instant
        `${msg} ${interferenceProp},${prop},${prop}`
      );
    }
  }
}