1
    2
    3
    4
    5
    6
    7
    8
    9
   10
   11
   12
   13
   14
   15
   16
   17
   18
   19
   20
   21
   22
   23
   24
   25
   26
   27
   28
   29
   30
   31
   32
   33
   34
   35
   36
   37
   38
   39
   40
   41
   42
   43
   44
   45
   46
   47
   48
   49
   50
   51
   52
   53
   54
   55
   56
   57
   58
   59
   60
   61
   62
   63
   64
   65
   66
   67
   68
   69
   70
   71
   72
   73
   74
   75
   76
   77
   78
   79
   80
   81
   82
   83
   84
   85
   86
   87
   88
   89
   90
   91
   92
   93
   94
   95
   96
   97
   98
   99
  100
  101
  102
  103
  104
  105
  106
  107
  108


content / test / data / compute_pressure / deliver_update_test.html [blame]

<!DOCTYPE html>
<html>
   <head>
      <title>Compute Pressure Browser Test</title>
   </head>
   <body>
      <iframe src="valid_token.html" id="same-origin"></iframe>
      <iframe src="/cross-site/b.com/title1.html" id="cross-origin"></iframe>
      <video src="../media/tulip2.webm" id="video"></video>

      <script>
         let dedicated_worker = null;
         let shared_worker = null;
         const same_origin_iframe = document.getElementById('same-origin');
         const cross_origin_iframe = document.getElementById('cross-origin');
         const video = document.getElementById('video');
         let stream = null;

         class ResultsTracker {
            constructor() {
               this.pendingResolve = null;
               this.samples = [];
            }

            processUpdates(updates) {
               this.samples = this.samples.concat(updates);
               if (this.pendingResolve !== null) {
                  this.pendingResolve();
                  this.pendingResolve = null;
               }
            }

            waitForUpdates(num) {
               if (this.samples.length == num) {
                  return Promise.resolve();
               }

               return new Promise((resolve) => {
                  this.pendingResolve = resolve;
               });
            }
         }

         const datasets = {
            frame: new ResultsTracker(),
            dedicatedWorker: new ResultsTracker(),
            sharedWorker: new ResultsTracker()
         };

         const observer = new PressureObserver((records) => {
            datasets.frame.processUpdates(records);
         });

         function startDedicatedWorker() {
            dedicated_worker = new Worker('observer-in-dedicated-worker.js');
            dedicated_worker.addEventListener('message', (e) => {
               if (e.data.type == 'data') {
                  datasets.dedicatedWorker.processUpdates(e.data.update);
               }
            });

            return new Promise((resolve, reject) => {
               dedicated_worker.postMessage({ command: 'start' });
               dedicated_worker.addEventListener('message', (e) => {
                  if (e.data.result == 'success') {
                     resolve('success');
                  } else if (e.data.result == 'fail') {
                     reject('Observer cannot start.');
                  } else {
                     reject('Got unexpected reply.');
                  }
               }, { once: true });
            });
         }

         function startSharedWorker() {
            shared_worker = new SharedWorker('observer-in-shared-worker.js');
            shared_worker.port.addEventListener('message', (e) => {
               if (e.data.type == 'data') {
                  datasets.sharedWorker.processUpdates(e.data.update);
               }
            });

            return new Promise((resolve, reject) => {
               shared_worker.port.start();
               shared_worker.port.postMessage({ command: 'start' });
               shared_worker.port.addEventListener('message', (e) => {
                  if (e.data.result == 'success') {
                     resolve('success');
                  } else if (e.data.result == 'fail') {
                     reject('Observer cannot start.');
                  } else {
                     reject('Got unexpected reply.');
                  }
               }, { once: true });
            });
         }

         async function startCapturing() {
            stream = await navigator.mediaDevices.getUserMedia({ video: true, audio: true });
         }

         function stopCapturing() {
            stream.getTracks().forEach(track => track.stop());
         }
      </script>
   </body>
</html>