Skip to main content

Browse the archive

Revision e9f36aa0be6522db24e0d27b293a78ba68214d02 authored by Ehsan Karamad on 25 April 2018, 15:35:03 UTC, committed by Blink WPT Bot on 25 April 2018, 15:45:19 UTC 
'vertical-scroll' for programmatic scrolling
 
If 'vertical-scroll' is disabled for an <iframe>, then it should not be
able to affect the vertical scroll position. One way to block is to use
scripted scrolling by calling "element.scrollIntoView()".

To block such frames (whose feature's disabled), programmatic recursive
scroll calls are not forwarded to parent frames. This means if a given
<iframe> is blocked, then all the calls to scrollIntoView() are limited
to the scope of frame (i.e., elements becoming visible in the frame).
This applies to all the nested <iframe>'s of a disabled frame as well
since they would have the feature disabled as part of propagating the
container policy.

Link to explainer/design document for "vertical-scroll":
https://docs.google.com/document/d/1qiWelnMlsOHuT_CQ0Zm_qEAf54HS5DhoIvEDHBlfqps/edit?usp=sharing

Bug: 611982
Change-Id: I0e06b399ad890e263128b997cfbb04eb3bdd1494
Reviewed-on: https://chromium-review.googlesource.com/1014191
Reviewed-by: Ian Clelland <iclelland@chromium.org>
Reviewed-by: Ehsan Karamad <ekaramad@chromium.org>
Reviewed-by: David Bokan <bokan@chromium.org>
Commit-Queue: Ehsan Karamad <ekaramad@chromium.org>
Cr-Commit-Position: refs/heads/master@{#553561}
1 parent 6c62c5b
Raw File
interfaces.https.html 
<!doctype html>
<meta charset=utf-8>
<title>WebRTC IDL Tests</title>
<script src="/resources/testharness.js"></script>
<script src="/resources/testharnessreport.js"></script>
<script src="/resources/WebIDLParser.js"></script>
<script src="/resources/idlharness.js"></script>
<script src="./RTCPeerConnection-helper.js"></script>
<script>
  'use strict';

  // The following helper functions are called from RTCPeerConnection-helper.js:
  //   generateAnswer()
  //   generateMediaStreamTrack()

  // Put the global IDL test objects under a parent object.
  // This allows easier search for the test cases when
  // viewing the web page
  const idlTestObjects = {};

  // Helper function to create RTCTrackEvent object
  function initTrackEvent() {
    const pc = new RTCPeerConnection();
    const transceiver = pc.addTransceiver('audio');
    const { sender, receiver } = transceiver;
    const { track } = receiver;
    return new RTCTrackEvent('track', {
      receiver, track, transceiver
    });
  }

  // List of async test driver functions
  const asyncInitTasks = [
    asyncInitCertificate,
    asyncInitTransports,
    asyncInitMediaStreamTrack,
  ];

  // Asynchronously generate an RTCCertificate
  function asyncInitCertificate() {
    return RTCPeerConnection.generateCertificate({
      name: 'RSASSA-PKCS1-v1_5',
      modulusLength: 2048,
      publicExponent: new Uint8Array([1, 0, 1]),
      hash: 'SHA-256'
    }).then(cert => {
      idlTestObjects.certificate = cert;
    });
  }

  // Asynchronously generate instances of
  // RTCSctpTransport, RTCDtlsTransport,
  // and RTCIceTransport
  function asyncInitTransports() {
    const pc = new RTCPeerConnection();
    pc.createDataChannel('test');

    // setting answer description initializes pc.sctp
    return pc.createOffer()
    .then(offer =>
      pc.setLocalDescription(offer)
      .then(() => generateAnswer(offer)))
    .then(answer => pc.setRemoteDescription(answer))
    .then(() => {
      const sctpTransport = pc.sctp;
      assert_true(sctpTransport instanceof RTCSctpTransport,
        'Expect pc.sctp to be instance of RTCSctpTransport');
      idlTestObjects.sctpTransport = sctpTransport;

      const dtlsTransport = sctpTransport.transport;
      assert_true(dtlsTransport instanceof RTCDtlsTransport,
        'Expect sctpTransport.transport to be instance of RTCDtlsTransport');
      idlTestObjects.dtlsTransport = dtlsTransport;

      const iceTransport = dtlsTransport.transport;
      idlTestObjects.iceTransport = iceTransport;
    });
  }

  // Asynchoronously generate MediaStreamTrack from getUserMedia
  function asyncInitMediaStreamTrack() {
    return navigator.mediaDevices.getUserMedia({ audio: true })
    .then(mediaStream => {
      const tracks = mediaStream.getTracks();
      assert_greater_than(tracks.length, 0,
        'Expect media stream to have at least one track');

      idlTestObjects.mediaStreamTrack = tracks[0];
    });
  }

  // Run all async test drivers, report and swallow any error
  // thrown/rejected. Proper test for correct initialization
  // of the objects are done in their respective test files.
  function asyncInit() {
    return Promise.all(asyncInitTasks.map(
      task => {
        const t = async_test(`Test driver for ${task.name}`);
        let promise;
        t.step(() => {
          promise = task().then(
            t.step_func_done(),
            t.step_func(err =>
              assert_unreached(`Failed to run ${task.name}: ${err}`)));
        });
        return promise;
      }));
  }

  promise_test(async t => {
    await asyncInit();

    const idlArray = new IdlArray();

    let webrtcIdl = fetch('/interfaces/webrtc-pc.idl').then(r => r.text());
    let mediacaptureMainIdl = fetch('/interfaces/mediacapture-main.idl').then(r => r.text());

    idlArray.add_untested_idls(mediacaptureMainIdl, { only: ['MediaStreamConstraints'] });
    idlArray.add_idls(webrtcIdl);

    idlArray.add_untested_idls('interface EventHandler {};');
    idlArray.add_idls('interface EventTarget {};');
    idlArray.add_idls('interface MediaStreamTrack : EventTarget {};');

    idlArray.add_objects({
      'RTCPeerConnection': [`new RTCPeerConnection()`],

      'RTCSessionDescription': [`new RTCSessionDescription({ type: 'offer' })`],

      'RTCIceCandidate': [`new RTCIceCandidate({ sdpMid: 1 })`],

      'RTCDataChannel': [`new RTCPeerConnection().createDataChannel('')`],

      'RTCRtpTransceiver': [`new RTCPeerConnection().addTransceiver('audio')`],

      'RTCRtpSender': [`new RTCPeerConnection().addTransceiver('audio').sender`],

      'RTCRtpReceiver': [`new RTCPeerConnection().addTransceiver('audio').receiver`],

      'RTCPeerConnectionIceEvent': [`new RTCPeerConnectionIceEvent('ice')`],

      'RTCPeerConnectionIceErrorEvent':
        [`new RTCPeerConnectionIceErrorEvent('ice-error', { errorCode: 701 });`],

      'RTCTrackEvent': [`initTrackEvent()`],

      'RTCErrorEvent': [`new RTCErrorEvent('error')`],

      'RTCDataChannelEvent': [`new RTCDataChannelEvent('channel',
        { channel: new RTCPeerConnection().createDataChannel('') })`],

      // Async initialized objects below

      'RTCCertificate': ['idlTestObjects.certificate'],

      'RTCSctpTransport': ['idlTestObjects.sctpTransport'],

      'RTCDtlsTransport': ['idlTestObjects.dtlsTransport'],

      'RTCIceTransport': ['idlTestObjects.iceTransport'],

      // Test on both MediaStreamTrack from getUserMedia and transceiver
      'MediaStreamTrack': [
        `idlTestObjects.mediaStreamTrack`,
        `generateMediaStreamTrack('audio')`]
    });

    idlArray.test();
  }, 'Main test driver');

  /*
    TODO
      RTCRtpContributingSource
      RTCRtpSynchronizationSource
      RTCDTMFSender
      RTCDTMFToneChangeEvent
      RTCIdentityProviderRegistrar
      RTCIdentityAssertion
   */
</script>
back to top