tor-browser

file_clipboard_common.js (11660B)

---

// This test is called from both test_clipboard_editor.html and test_clipboard_noeditor.html
// This is to test that the code works both in the presence of a contentEditable node, and in the absense of one
var WATCH_TIMEOUT = 300;

// Some global variables to make the debug messages easier to track down
var gTestN0 = 0,
 gTestN1 = 0,
 gTestN2 = 0;
function testLoc() {
 return " " + gTestN0 + " - " + gTestN1 + " - " + gTestN2;
}

// Listen for cut & copy events
var gCopyCount = 0,
 gCutCount = 0;
document.addEventListener("copy", function () {
 gCopyCount++;
});
document.addEventListener("cut", function () {
 gCutCount++;
});

// Helper methods
function selectNode(aSelector, aCb) {
 var dn = document.querySelector(aSelector);
 var range = document.createRange();
 range.selectNodeContents(dn);
 window.getSelection().removeAllRanges();
 window.getSelection().addRange(range);
 if (aCb) {
   aCb();
 }
}

function selectInputNode(aSelector, aCb) {
 var dn = document.querySelector(aSelector);
 synthesizeMouse(dn, 10, 10, {});
 SimpleTest.executeSoon(function () {
   synthesizeKey("A", { accelKey: true });
   // Clear the user activation state which is set from synthesized mouse and
   // key event.
   SpecialPowers.wrap(document).clearUserGestureActivation();
   SimpleTest.executeSoon(aCb);
 });
}

// Callback functions for attaching to the button
function execCommand(aCommand, aShouldSucceed, aAsync = false) {
 var cb = function (e) {
   e.preventDefault();
   document.removeEventListener("keydown", cb);

   if (aAsync) {
     setTimeout(() => {
       is(
         aShouldSucceed,
         document.execCommand(aCommand),
         "Keydown caused " + aCommand + " invocation" + testLoc()
       );
     }, 0);
   } else {
     is(
       aShouldSucceed,
       document.execCommand(aCommand),
       "Keydown caused " + aCommand + " invocation" + testLoc()
     );
   }
 };
 return cb;
}

// The basic test set. Tries to cut/copy everything
function cutCopyAll(
 aDoCut,
 aDoCopy,
 aDone,
 aNegate,
 aClipOverride,
 aJustClipboardNegate
) {
 var execCommandAlwaysSucceed = !!(aClipOverride || aJustClipboardNegate);

 function waitForClipboard(aCond, aSetup, aNext, aNegateOne) {
   if (aClipOverride) {
     aCond = aClipOverride;
     aNegateOne = false;
   }
   if (aNegate || aNegateOne || aJustClipboardNegate) {
     SimpleTest.waitForClipboard(
       null,
       aSetup,
       aNext,
       aNext,
       "text/plain",
       WATCH_TIMEOUT,
       true
     );
   } else {
     SimpleTest.waitForClipboard(aCond, aSetup, aNext, aNext);
   }
 }

 function validateCutCopy(aExpectedCut, aExpectedCopy) {
   if (aNegate) {
     aExpectedCut = aExpectedCopy = 0;
   } // When we are negating - we always expect callbacks not to be run

   is(
     aExpectedCut,
     gCutCount,
     (aExpectedCut > 0
       ? "Expect cut callback to run"
       : "Expect cut callback not to run") + testLoc()
   );
   is(
     aExpectedCopy,
     gCopyCount,
     (aExpectedCopy > 0
       ? "Expect copy callback to run"
       : "Expect copy callback not to run") + testLoc()
   );
   gCutCount = gCopyCount = 0;
 }

 function step(n) {
   function nextStep() {
     step(n + 1);
   }

   // Reset the user activation state before running next test.
   SpecialPowers.wrap(document).clearUserGestureActivation();

   document.querySelector("span").textContent = "span text";
   document.querySelector("input[type=text]").value = "text text";
   document.querySelector("input[type=password]").value = "password text";
   document.querySelector("textarea").value = "textarea text";

   var contentEditableNode = document.querySelector(
     "div[contentEditable=true]"
   );
   if (contentEditableNode) {
     contentEditableNode.textContent = "contenteditable text";
   }

   gTestN2 = n;
   switch (n) {
     case 0:
       // copy on readonly selection
       selectNode("span");
       waitForClipboard(
         "span text",
         function () {
           aDoCopy(true);
         },
         nextStep
       );
       return;

     case 1:
       validateCutCopy(0, 1);

       // cut on readonly selection
       selectNode("span");

       waitForClipboard(
         "span text",
         function () {
           aDoCut(execCommandAlwaysSucceed);
         },
         nextStep,
         true
       );
       return;

     case 2:
       validateCutCopy(1, 0);

       // copy on textbox selection
       selectInputNode("input[type=text]", nextStep);
       return;

     case 3:
       waitForClipboard(
         "text text",
         function () {
           selectInputNode("input[type=text]", function () {
             aDoCopy(true);
           });
         },
         nextStep
       );
       return;

     case 4:
       validateCutCopy(0, 1);

       // cut on textbox selection
       selectInputNode("input[type=text]", nextStep);
       return;

     case 5:
       waitForClipboard(
         "text text",
         function () {
           aDoCut(true);
         },
         nextStep
       );
       return;

     case 6:
       validateCutCopy(1, 0);

       // copy on password selection
       selectInputNode("input[type=password]", nextStep);
       return;

     case 7:
       waitForClipboard(
         null,
         function () {
           aDoCopy(execCommandAlwaysSucceed);
         },
         nextStep,
         true
       );
       return;

     case 8:
       validateCutCopy(0, 1);

       // cut on password selection
       selectInputNode("input[type=password]", nextStep);
       return;

     case 9:
       waitForClipboard(
         null,
         function () {
           aDoCut(execCommandAlwaysSucceed);
         },
         nextStep,
         true
       );
       return;

     case 10:
       validateCutCopy(1, 0);

       // copy on textarea selection
       selectInputNode("textarea", nextStep);
       return;

     case 11:
       waitForClipboard(
         "textarea text",
         function () {
           aDoCopy(true);
         },
         nextStep
       );
       return;

     case 12:
       validateCutCopy(0, 1);

       // cut on password selection
       selectInputNode("textarea", nextStep);
       return;

     case 13:
       waitForClipboard(
         "textarea text",
         function () {
           aDoCut(true);
         },
         nextStep
       );
       return;

     case 14:
       validateCutCopy(1, 0);

       // copy on no selection
       document.querySelector("textarea").blur();

       waitForClipboard(
         null,
         function () {
           aDoCopy(true);
         },
         nextStep,
         true
       );
       return;

     case 15:
       validateCutCopy(0, 1);

       // cut on no selection
       waitForClipboard(
         null,
         function () {
           aDoCut(execCommandAlwaysSucceed);
         },
         nextStep,
         true
       );
       return;

     case 16:
       validateCutCopy(1, 0);

       if (!document.querySelector("div[contentEditable=true]")) {
         // We're done! (no contentEditable node!)
         step(-1);
         return;
       }
       break;

     case 17:
       // copy on contenteditable selection
       waitForClipboard(
         "contenteditable text",
         function () {
           selectNode("div[contentEditable=true]", function () {
             aDoCopy(true);
           });
         },
         nextStep
       );
       return;

     case 18:
       validateCutCopy(0, 1);
       break;

     case 19:
       // cut on contenteditable selection
       waitForClipboard(
         "contenteditable text",
         function () {
           selectNode("div[contentEditable=true]", function () {
             aDoCut(true);
           });
         },
         nextStep
       );
       return;

     case 20:
       validateCutCopy(1, 0);
       break;

     default:
       aDone();
       return;
   }

   SimpleTest.executeSoon(function () {
     step(n + 1);
   });
 }

 step(0);
}

function allMechanisms(aCb, aClipOverride, aNegateAll) {
 function testStep(n) {
   gTestN1 = n;
   switch (n) {
     /** Test for Bug 1012662 */
     case 0:
       // Keyboard issued
       cutCopyAll(
         function docut() {
           synthesizeKey("x", { accelKey: true });
         },
         function docopy() {
           synthesizeKey("c", { accelKey: true });
         },
         function done() {
           testStep(n + 1);
         },
         false,
         aClipOverride,
         aNegateAll
       );
       return;

     case 1:
       // Button issued
       cutCopyAll(
         function docut(aSucc) {
           document.addEventListener("keydown", execCommand("cut", aSucc));
           sendString("Q");
         },
         function docopy(aSucc) {
           document.addEventListener("keydown", execCommand("copy", aSucc));
           sendString("Q");
         },
         function done() {
           testStep(n + 1);
         },
         false,
         aClipOverride,
         aNegateAll
       );
       return;

     case 2:
       // Not triggered by user gesture
       cutCopyAll(
         function doCut() {
           is(
             false,
             document.execCommand("cut"),
             "Can't directly execCommand not in a user callback"
           );
         },
         function doCopy() {
           is(
             false,
             document.execCommand("copy"),
             "Can't directly execCommand not in a user callback"
           );
         },
         function done() {
           testStep(n + 1);
         },
         true,
         aClipOverride,
         aNegateAll
       );
       return;

     /** Test for Bug 1597857 */
     case 3:
       // Button issued async
       cutCopyAll(
         function docut(aSucc) {
           document.addEventListener(
             "keydown",
             execCommand("cut", aSucc, true)
           );
           sendString("Q");
         },
         function docopy(aSucc) {
           document.addEventListener(
             "keydown",
             execCommand("copy", aSucc, true)
           );
           sendString("Q");
         },
         function done() {
           testStep(n + 1);
         },
         false,
         aClipOverride,
         aNegateAll
       );
       return;

     default:
       aCb();
   }
 }
 testStep(0);
}

// Run the tests
SimpleTest.waitForExplicitFinish();
SimpleTest.requestLongerTimeout(5); // On the emulator - this times out occasionally
SimpleTest.waitForFocus(function () {
 function justCancel(aEvent) {
   aEvent.preventDefault();
 }

 function override(aEvent) {
   aEvent.clipboardData.setData("text/plain", "overridden");
   aEvent.preventDefault();
 }

 allMechanisms(function () {
   gTestN0 = 1;
   document.addEventListener("cut", override);
   document.addEventListener("copy", override);

   allMechanisms(function () {
     gTestN0 = 2;
     document.removeEventListener("cut", override);
     document.removeEventListener("copy", override);
     document.addEventListener("cut", justCancel);
     document.addEventListener("copy", justCancel);

     allMechanisms(
       function () {
         SimpleTest.finish();
       },
       null,
       true
     );
   }, "overridden");
 });
});