change connection quality to take layer suspension into account (#762)

* change connection quality to take layer suspension into account

modules/RTC/BandwidthLimiter.js

         this._bandwidthLimits.set(mediaType, limitKbps);
     }
 
+    /**
+     * Get the current bandwidth limit
+     * @param {String} mediaType the mline media type for which to get the
+     * bandwidth limit
+     * @return {Number} the bandwidth limit in kbps if it exists, undefined
+     * otherwise
+     */
+    getBandwidthLimit(mediaType) {
+        return this._bandwidthLimits.get(mediaType);
+    }
+
     /**
      * Enforce any configured bandwidth limits (or lack thereof) in the given
      * sdp

modules/connectivity/ConnectionQuality.js

  */
 let startBitrate = 800;
 
+
+/**
+ * The current cap (in kbps) put on the video stream (or null if there isn't
+ * a cap).  If there is a cap, we'll take it into account when calculating
+ * the current quality.
+ */
+let videoBitrateCap = null;
+
 /**
  * Gets the expected bitrate (in kbps) in perfect network conditions.
  * @param simulcast {boolean} whether simulcast is enabled or not.
          */
         this._timeVideoUnmuted = -1;
 
+        /**
+         * The time at which a video bitrate cap was last removed.  We use
+         * this to calculate how much time we, as a sender, have had to
+         * ramp-up
+         */
+        this._timeLastBwCapRemoved = -1;
 
         // We assume a global startBitrate value for the sake of simplicity.
         if (options.startBitrate && options.startBitrate > 0) {
         } else {
             // Calculate a value based on the sending bitrate.
 
-            // time since sending of video was enabled.
-            const millisSinceStart = window.performance.now()
-                    - Math.max(this._timeVideoUnmuted, this._timeIceConnected);
-
             // Figure out if simulcast is in use
             const activeTPC = this._conference.getActivePeerConnection();
             const isSimulcastOn
                 = Boolean(activeTPC && activeTPC.isSimulcastOn());
 
+            const newVideoBitrateCap
+                = activeTPC && activeTPC.bandwidthLimiter
+                && activeTPC.bandwidthLimiter.getBandwidthLimit('video');
+
+            // If we had a cap set but there isn't one now, then it has
+            // just been 'lifted', so we should treat this like a new
+            // ramp up.
+            if (!newVideoBitrateCap && videoBitrateCap) {
+                this._timeLastBwCapRemoved = window.performance.now();
+
+                // Set the start bitrate to whatever we were just capped to
+                startBitrate = videoBitrateCap;
+            }
+            videoBitrateCap = newVideoBitrateCap;
+
+            // time since sending of video was enabled.
+            const millisSinceStart = window.performance.now()
+                - Math.max(this._timeVideoUnmuted,
+                    this._timeIceConnected,
+                    this._timeLastBwCapRemoved);
+
             // expected sending bitrate in perfect conditions
             let target
                 = getTarget(isSimulcastOn, resolution, millisSinceStart);
 
             target = Math.min(0.9 * target, MAX_TARGET_BITRATE);
 
+            if (videoBitrateCap) {
+                target = Math.min(target, videoBitrateCap);
+            }
+
             quality = 100 * this._localStats.bitrate.upload / target;
 
             // Whatever the bitrate, drop early if there is significant loss