Implements getDisplayMedia when available on chrome.

modules/RTC/RTCUtils.js

     return constraints;
 }
 
+/**
+ * Generates constraints for screen sharing when using getDisplayMedia.
+ * The constraints(MediaTrackConstraints) are applied to the resulting track.
+ *
+ * @returns {Object} - MediaTrackConstraints constraints.
+ */
+function getTrackSSConstraints(options = {}) {
+    // we used to set height and width in the constraints, but this can lead
+    // to inconsistencies if the browser is on a lower resolution screen
+    // and we share a screen with bigger resolution, so they are now not set
+    const constraints = {
+        frameRate: SS_DEFAULT_FRAME_RATE
+    };
+    const { desktopSharingFrameRate } = options;
+
+    if (desktopSharingFrameRate && desktopSharingFrameRate.max) {
+        constraints.frameRate = desktopSharingFrameRate.max;
+    }
+
+    return constraints;
+}
+
 /**
  * Sets the availbale devices based on the options we requested and the
  * streams we received.
                 {
                     ...desktopSharingExtensionExternalInstallation,
                     desktopSharingSources,
-                    gumOptions
+                    gumOptions,
+                    trackOptions: getTrackSSConstraints(options)
                 },
                 stream => {
                     resolve(stream);
             desktopSharingSources: options.desktopSharingSources,
             gumOptions: {
                 frameRate: options.desktopSharingFrameRate
-            }
+            },
+            trackOptions: getTrackSSConstraints(options)
         };
     }
 

modules/RTC/ScreenObtainer.js

                 logger.info('Chrome extension not supported until ver 34');
 
                 return null;
+            } else if (browser.supportsGetDisplayMedia()
+                        && !options.desktopSharingChromeDisabled) {
+
+                return this.obtainScreenFromGetDisplayMedia;
             } else if (options.desktopSharingChromeDisabled
-                || options.desktopSharingChromeMethod === false
                 || !options.desktopSharingChromeExtId) {
 
-                // TODO: desktopSharingChromeMethod is deprecated, remove.
                 return null;
             }
 
             }
 
             return this.obtainScreenOnFirefox;
-        } else if (browser.isEdge() && navigator.getDisplayMedia) {
-            return (_, onSuccess, onFailure) => {
-                navigator.getDisplayMedia({ video: true })
-                    .then(stream => onSuccess({
-                        stream,
-                        sourceId: stream.id
-                    }))
-                    .catch(onFailure);
-            };
+        } else if (browser.isEdge() && browser.supportsGetDisplayMedia()) {
+            return this.obtainScreenFromGetDisplayMedia;
         }
 
         logger.log(
                 this.checkForChromeExtensionOnInterval(options,
                     streamCallback, failCallback);
             });
+    },
+
+    /**
+     * Obtains a screen capture stream using getDisplayMedia.
+     *
+     * @param callback - The success callback.
+     * @param errorCallback - The error callback.
+     */
+    obtainScreenFromGetDisplayMedia(options, callback, errorCallback) {
+        navigator.getDisplayMedia({ video: true })
+            .then(stream => {
+                let applyConstraintsPromise;
+
+                if (stream
+                    && stream.getTracks()
+                    && stream.getTracks().length > 0) {
+                    applyConstraintsPromise = stream.getTracks()[0]
+                        .applyConstraints(options.trackOptions);
+                } else {
+                    applyConstraintsPromise = Promise.resolve();
+                }
+
+                applyConstraintsPromise.then(() =>
+                    callback({
+                        stream,
+                        sourceId: stream.id
+                    }));
+            })
+            .catch(() =>
+                errorCallback(new JitsiTrackError(JitsiTrackErrors
+                    .CHROME_EXTENSION_USER_CANCELED)));
     }
 };
 

modules/browser/BrowserCapabilities.js

     usesAdapter() {
         return this.usesNewGumFlow() || this.isEdge();
     }
+
+    /**
+     * Checks if the browser supposrts getDisplayMedia.
+     * @returns {boolean} {@code true} if the browser supposrts getDisplayMedia.
+     */
+    supportsGetDisplayMedia() {
+        return navigator.getDisplayMedia !== undefined;
+    }
 }