[PTZ] Copy image capture settings when cloning MediaStreamTrack

This CL makes sure all ImageCapture related capabilities, constraints,
and settings are copied to the cloned MediaStreamTrack. This wasn't the
case before.

Bug: 934063
Change-Id: I783d0804e56f46152e1ba02255ff454dd1ba76aa
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2567917Reviewed-by: Guido Urdaneta <guidou@chromium.org>
Reviewed-by: Reilly Grant <reillyg@chromium.org>
Commit-Queue: François Beaufort <beaufort.francois@gmail.com>
Cr-Commit-Position: refs/heads/master@{#833827}

third_party/blink/renderer/modules/imagecapture/image_capture.cc

@@ -1222,6 +1222,156 @@ bool ImageCapture::IsPageVisible() {
   return DomWindow() ? DomWindow()->document()->IsPageVisible() : false;
 }
 
+ImageCapture* ImageCapture::Clone() const {
+  ImageCapture* clone = MakeGarbageCollected<ImageCapture>(
+      GetExecutionContext(), stream_track_, HasPanTiltZoomPermissionGranted(),
+      /*callback=*/base::DoNothing());
+
+  // Copy capabilities.
+  if (capabilities_->hasWhiteBalanceMode()) {
+    clone->capabilities_->setWhiteBalanceMode(
+        capabilities_->whiteBalanceMode());
+  }
+  if (capabilities_->hasExposureMode())
+    clone->capabilities_->setExposureMode(capabilities_->exposureMode());
+  if (capabilities_->hasFocusMode())
+    clone->capabilities_->setFocusMode(capabilities_->focusMode());
+  if (capabilities_->hasExposureCompensation()) {
+    clone->capabilities_->setExposureCompensation(
+        capabilities_->exposureCompensation());
+  }
+  if (capabilities_->hasExposureTime())
+    clone->capabilities_->setExposureTime(capabilities_->exposureTime());
+  if (capabilities_->hasColorTemperature()) {
+    clone->capabilities_->setColorTemperature(
+        capabilities_->colorTemperature());
+  }
+  if (capabilities_->hasIso())
+    clone->capabilities_->setIso(capabilities_->iso());
+  if (capabilities_->hasBrightness())
+    clone->capabilities_->setBrightness(capabilities_->brightness());
+  if (capabilities_->hasContrast())
+    clone->capabilities_->setContrast(capabilities_->contrast());
+  if (capabilities_->hasSaturation())
+    clone->capabilities_->setSaturation(capabilities_->saturation());
+  if (capabilities_->hasSharpness())
+    clone->capabilities_->setSharpness(capabilities_->sharpness());
+  if (capabilities_->hasFocusDistance())
+    clone->capabilities_->setFocusDistance(capabilities_->focusDistance());
+  if (capabilities_->hasPan())
+    clone->capabilities_->setPan(capabilities_->pan());
+  if (capabilities_->hasTilt())
+    clone->capabilities_->setTilt(capabilities_->tilt());
+  if (capabilities_->hasZoom())
+    clone->capabilities_->setZoom(capabilities_->zoom());
+  if (capabilities_->hasTorch())
+    clone->capabilities_->setTorch(capabilities_->torch());
+
+  // Copy settings.
+  if (settings_->hasWhiteBalanceMode())
+    clone->settings_->setWhiteBalanceMode(settings_->whiteBalanceMode());
+  if (settings_->hasExposureMode())
+    clone->settings_->setExposureMode(settings_->exposureMode());
+  if (settings_->hasFocusMode())
+    clone->settings_->setFocusMode(settings_->focusMode());
+  if (settings_->hasPointsOfInterest() &&
+      !settings_->pointsOfInterest().IsEmpty()) {
+    clone->settings_->setPointsOfInterest(settings_->pointsOfInterest());
+  }
+  if (settings_->hasExposureCompensation()) {
+    clone->settings_->setExposureCompensation(
+        settings_->exposureCompensation());
+  }
+  if (settings_->hasExposureTime())
+    clone->settings_->setExposureTime(settings_->exposureTime());
+  if (settings_->hasColorTemperature())
+    clone->settings_->setColorTemperature(settings_->colorTemperature());
+  if (settings_->hasIso())
+    clone->settings_->setIso(settings_->iso());
+  if (settings_->hasBrightness())
+    clone->settings_->setBrightness(settings_->brightness());
+  if (settings_->hasContrast())
+    clone->settings_->setContrast(settings_->contrast());
+  if (settings_->hasSaturation())
+    clone->settings_->setSaturation(settings_->saturation());
+  if (settings_->hasSharpness())
+    clone->settings_->setSharpness(settings_->sharpness());
+  if (settings_->hasFocusDistance())
+    clone->settings_->setFocusDistance(settings_->focusDistance());
+  if (settings_->hasPan())
+    clone->settings_->setPan(settings_->pan());
+  if (settings_->hasTilt())
+    clone->settings_->setTilt(settings_->tilt());
+  if (settings_->hasZoom())
+    clone->settings_->setZoom(settings_->zoom());
+  if (settings_->hasTorch())
+    clone->settings_->setTorch(settings_->torch());
+
+  if (!current_constraints_)
+    return clone;
+
+  // Copy current constraints.
+  clone->current_constraints_ = MediaTrackConstraintSet::Create();
+  if (current_constraints_->hasWhiteBalanceMode()) {
+    clone->current_constraints_->setWhiteBalanceMode(
+        current_constraints_->whiteBalanceMode());
+  }
+  if (current_constraints_->hasExposureMode()) {
+    clone->current_constraints_->setExposureMode(
+        current_constraints_->exposureMode());
+  }
+  if (current_constraints_->hasFocusMode()) {
+    clone->current_constraints_->setFocusMode(
+        current_constraints_->focusMode());
+  }
+  if (current_constraints_->hasPointsOfInterest()) {
+    clone->current_constraints_->setPointsOfInterest(
+        current_constraints_->pointsOfInterest());
+  }
+  if (current_constraints_->hasExposureCompensation()) {
+    clone->current_constraints_->setExposureCompensation(
+        current_constraints_->exposureCompensation());
+  }
+  if (current_constraints_->hasExposureTime()) {
+    clone->current_constraints_->setExposureTime(
+        current_constraints_->exposureTime());
+  }
+  if (current_constraints_->hasColorTemperature()) {
+    clone->current_constraints_->setColorTemperature(
+        current_constraints_->colorTemperature());
+  }
+  if (current_constraints_->hasIso())
+    clone->current_constraints_->setIso(current_constraints_->iso());
+  if (current_constraints_->hasBrightness()) {
+    clone->current_constraints_->setBrightness(
+        current_constraints_->brightness());
+  }
+  if (current_constraints_->hasContrast())
+    clone->current_constraints_->setContrast(current_constraints_->contrast());
+  if (current_constraints_->hasSaturation()) {
+    clone->current_constraints_->setSaturation(
+        current_constraints_->saturation());
+  }
+  if (current_constraints_->hasSharpness()) {
+    clone->current_constraints_->setSharpness(
+        current_constraints_->sharpness());
+  }
+  if (current_constraints_->hasFocusDistance()) {
+    clone->current_constraints_->setFocusDistance(
+        current_constraints_->focusDistance());
+  }
+  if (current_constraints_->hasPan())
+    clone->current_constraints_->setPan(current_constraints_->pan());
+  if (current_constraints_->hasTilt())
+    clone->current_constraints_->setTilt(current_constraints_->tilt());
+  if (current_constraints_->hasZoom())
+    clone->current_constraints_->setZoom(current_constraints_->zoom());
+  if (current_constraints_->hasTorch())
+    clone->current_constraints_->setTorch(current_constraints_->torch());
+
+  return clone;
+}
+
 void ImageCapture::Trace(Visitor* visitor) const {
   visitor->Trace(stream_track_);
   visitor->Trace(service_);

third_party/blink/renderer/modules/imagecapture/image_capture.h

@@ -86,6 +86,10 @@ class MODULES_EXPORT ImageCapture final
   bool HasPanTiltZoomPermissionGranted() const;
   bool HasZoomPermissionGranted() const;
 
+  // Called by MediaStreamTrack::clone() to get a clone with same capabilities,
+  // settings, and constraints.
+  ImageCapture* Clone() const;
+
   void Trace(Visitor*) const override;
 
  private:

third_party/blink/renderer/modules/mediastream/media_stream_track.cc

@@ -426,6 +426,9 @@ MediaStreamTrack* MediaStreamTrack::clone(ScriptState* script_state) {
       ExecutionContext::From(script_state), cloned_component, ready_state_,
       base::DoNothing());
   DidCloneMediaStreamTrack(Component(), cloned_component);
+  if (image_capture_) {
+    cloned_track->image_capture_ = image_capture_->Clone();
+  }
   return cloned_track;
 }
 

third_party/blink/web_tests/android/ChromiumWPTExpectations

@@ -3214,6 +3214,7 @@ crbug.com/1050754 external/wpt/mediacapture-image/MediaStreamTrack-applyConstrai
 crbug.com/1050754 external/wpt/mediacapture-image/MediaStreamTrack-applyConstraints-getSettings.https.html [ Failure ]
 crbug.com/1050754 external/wpt/mediacapture-image/MediaStreamTrack-applyConstraints-reject.https.html [ Failure ]
 crbug.com/1050754 external/wpt/mediacapture-image/MediaStreamTrack-applyConstraints.https.html [ Failure ]
+crbug.com/1050754 external/wpt/mediacapture-image/MediaStreamTrack-clone.https.html [ Failure ]
 crbug.com/1050754 external/wpt/mediacapture-image/MediaStreamTrack-getCapabilities.https.html [ Failure ]
 crbug.com/1050754 external/wpt/mediacapture-image/MediaStreamTrack-getConstraints.https.html [ Failure ]
 crbug.com/1050754 external/wpt/mediacapture-image/MediaStreamTrack-getSettings.https.html [ Failure ]

third_party/blink/web_tests/android/WeblayerWPTExpectations

@@ -3186,6 +3186,7 @@ crbug.com/1050754 external/wpt/mediacapture-image/MediaStreamTrack-applyConstrai
 crbug.com/1050754 external/wpt/mediacapture-image/MediaStreamTrack-applyConstraints-getSettings.https.html [ Failure ]
 crbug.com/1050754 external/wpt/mediacapture-image/MediaStreamTrack-applyConstraints-reject.https.html [ Failure ]
 crbug.com/1050754 external/wpt/mediacapture-image/MediaStreamTrack-applyConstraints.https.html [ Failure ]
+crbug.com/1050754 external/wpt/mediacapture-image/MediaStreamTrack-clone.https.html [ Failure ]
 crbug.com/1050754 external/wpt/mediacapture-image/MediaStreamTrack-getCapabilities.https.html [ Failure ]
 crbug.com/1050754 external/wpt/mediacapture-image/MediaStreamTrack-getConstraints.https.html [ Failure ]
 crbug.com/1050754 external/wpt/mediacapture-image/MediaStreamTrack-getSettings.https.html [ Failure ]

third_party/blink/web_tests/android/WebviewWPTExpectations

@@ -3444,6 +3444,7 @@ crbug.com/1050754 external/wpt/mediacapture-image/MediaStreamTrack-applyConstrai
 crbug.com/1050754 external/wpt/mediacapture-image/MediaStreamTrack-applyConstraints-getSettings.https.html [ Failure ]
 crbug.com/1050754 external/wpt/mediacapture-image/MediaStreamTrack-applyConstraints-reject.https.html [ Failure ]
 crbug.com/1050754 external/wpt/mediacapture-image/MediaStreamTrack-applyConstraints.https.html [ Failure ]
+crbug.com/1050754 external/wpt/mediacapture-image/MediaStreamTrack-clone.https.html [ Failure ]
 crbug.com/1050754 external/wpt/mediacapture-image/MediaStreamTrack-getCapabilities.https.html [ Failure ]
 crbug.com/1050754 external/wpt/mediacapture-image/MediaStreamTrack-getConstraints.https.html [ Failure ]
 crbug.com/1050754 external/wpt/mediacapture-image/MediaStreamTrack-getSettings.https.html [ Failure ]

third_party/blink/web_tests/external/wpt/mediacapture-image/MediaStreamTrack-clone.https.html

+<!DOCTYPE html>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script src="/resources/testdriver.js"></script>
+<script src="/resources/testdriver-vendor.js"></script>
+<script src="/mediacapture-image/resources/imagecapture-helpers.js"></script>
+<script>
+
+// This test verifies that we can set some nondefault constraints, then clone a
+// MediaStreamTrack and check that the cloned constraints are the same as the
+// original, with a mock Mojo service implementation.
+image_capture_test(async (t, imageCaptureTest) => {
+  await test_driver.set_permission({name: 'camera', panTiltZoom: true},
+        'granted', false);
+
+  const constraints = { advanced : [{ whiteBalanceMode : 'single-shot',
+                                      exposureMode     : 'manual',
+                                      focusMode        : 'single-shot',
+
+                                      pointsOfInterest : [{x : 0.1, y : 0.2},
+                                                          {x : 0.3, y : 0.4}],
+
+                                      exposureCompensation : 133.77,
+                                      exposureTime         : 10000,
+                                      colorTemperature     : 6000,
+                                      iso                  : 120.0,
+
+                                      brightness           : 3,
+                                      contrast             : 4,
+                                      saturation           : 5,
+                                      sharpness            : 6,
+                                      focusDistance        : 7,
+
+                                      pan                  : 8,
+                                      tilt                 : 9,
+                                      zoom                 : 3.141592,
+
+                                      torch                : true
+                                    }]};
+
+    let stream = await navigator.mediaDevices.getUserMedia({video: true});
+    let originalVideoTrack = stream.getVideoTracks()[0];
+
+    await originalVideoTrack.applyConstraints(constraints);
+
+    let appliedConstraints = originalVideoTrack.getConstraints();
+
+    let clonedVideoTrack = originalVideoTrack.clone();
+    let appliedClonedConstraints = clonedVideoTrack.getConstraints();
+    assert_true('advanced' in appliedClonedConstraints);
+    assert_equals(appliedClonedConstraints.advanced.length, 1);
+    const appliedClonedAdvancedConstraints = appliedClonedConstraints.advanced[0];
+
+    // Check that |appliedClonedAdvancedConstraints| and |appliedAdvancedConstraints| are equal.
+    const appliedAdvancedConstraints = appliedConstraints.advanced[0];
+    assert_equals(appliedAdvancedConstraints.length, appliedClonedAdvancedConstraints.length);
+    Object.keys(appliedClonedAdvancedConstraints).forEach((key, value) => {
+      assert_not_equals(appliedAdvancedConstraints[key], undefined, 'key ' + key);
+      if (key != 'pointsOfInterest') {
+        assert_equals(appliedAdvancedConstraints[key], appliedClonedAdvancedConstraints[key], key);
+      } else {
+        assert_point2d_array_approx_equals(appliedAdvancedConstraints[key],
+                                           appliedClonedAdvancedConstraints[key], 0.01);
+      }
+    });
+
+    assert_equals(appliedAdvancedConstraints.whiteBalanceMode,
+                  appliedClonedAdvancedConstraints.whiteBalanceMode,
+                  'whiteBalanceMode');
+    assert_equals(appliedAdvancedConstraints.exposureMode,
+                  appliedClonedAdvancedConstraints.exposureMode,
+                  'exposureMode');
+    assert_equals(appliedAdvancedConstraints.focusMode,
+                  appliedClonedAdvancedConstraints.focusMode,
+                  'focusMode');
+
+    assert_point2d_array_approx_equals(
+        appliedAdvancedConstraints.pointsOfInterest,
+        appliedClonedAdvancedConstraints.pointsOfInterest,
+        0.01);
+
+    assert_equals(appliedAdvancedConstraints.exposureCompensation,
+                  appliedClonedAdvancedConstraints.exposureCompensation,
+                  'exposureCompensation');
+    assert_equals(appliedAdvancedConstraints.exposureTime,
+                  appliedClonedAdvancedConstraints.exposureTime,
+                  'exposureTime');
+    assert_equals(appliedAdvancedConstraints.colorTemperature,
+                  appliedClonedAdvancedConstraints.colorTemperature,
+                  'colorTemperature');
+    assert_equals(appliedAdvancedConstraints.iso,
+                  appliedClonedAdvancedConstraints.iso,
+                  'iso');
+    assert_equals(appliedAdvancedConstraints.brightness,
+                  appliedClonedAdvancedConstraints.brightness,
+                  'brightness');
+    assert_equals(appliedAdvancedConstraints.contrast,
+                  appliedClonedAdvancedConstraints.contrast,
+                  'constrast');
+    assert_equals(appliedAdvancedConstraints.saturation,
+                  appliedClonedAdvancedConstraints.saturation,
+                  'saturation');
+    assert_equals(appliedAdvancedConstraints.sharpness,
+                  appliedClonedAdvancedConstraints.sharpness,
+                  'sharpness');
+    assert_equals(appliedAdvancedConstraints.focusDistance,
+                  appliedClonedAdvancedConstraints.focusDistance,
+                  'focusDistance');
+
+    assert_equals(appliedAdvancedConstraints.pan,
+                  appliedClonedAdvancedConstraints.pan,
+                  'pan');
+    assert_equals(appliedAdvancedConstraints.tilt,
+                  appliedClonedAdvancedConstraints.tilt,
+                  'tilt');
+    assert_equals(appliedAdvancedConstraints.zoom,
+                  appliedClonedAdvancedConstraints.zoom,
+                  'zoom');
+
+    assert_equals(appliedAdvancedConstraints.torch,
+                  appliedClonedAdvancedConstraints.torch,
+                  'torch');
+}, 'checks MediaStreamTrack.clone() gets same applied constraints');
+
+// This test verifies that MediaStreamTrack ImageCapture settings are copied
+// when cloning a MediaStreamTrack.
+image_capture_test(async (t, imageCaptureTest) => {
+  await test_driver.set_permission({name: 'camera', panTiltZoom: true},
+        'granted', false);
+
+  let stream = await navigator.mediaDevices.getUserMedia({video: true});
+  let originalVideoTrack = stream.getVideoTracks()[0];
+  let clonedVideoTrack = originalVideoTrack.clone();
+
+  let settings = originalVideoTrack.getSettings();
+  let clonedSettings = clonedVideoTrack.getSettings();
+
+  assert_equals(settings.whiteBalanceMode,
+                clonedSettings.whiteBalanceMode,
+                'whiteBalanceMode');
+  assert_equals(settings.exposureMode,
+                clonedSettings.exposureMode,
+                'exposureMode;');
+  assert_equals(settings.focusMode,
+                clonedSettings.focusMode,
+                'focusMode');
+
+  assert_point2d_array_approx_equals(
+      settings.pointsOfInterest,
+      clonedSettings.pointsOfInterest,
+      0.01);
+
+  assert_equals(settings.exposureCompensation,
+                clonedSettings.exposureCompensation,
+                'exposureCompensation');
+  assert_equals(settings.exposureTime,
+                clonedSettings.exposureTime,
+                'exposureTime');
+  assert_equals(settings.colorTemperature,
+                clonedSettings.colorTemperature,
+                'colorTemperature');
+  assert_equals(settings.iso,
+                clonedSettings.iso,
+                'iso');
+
+  assert_equals(settings.brightness,
+                clonedSettings.brightness,
+                'brightness');
+  assert_equals(settings.contrast,
+                clonedSettings.contrast,
+                'contrast');
+  assert_equals(settings.saturation,
+                clonedSettings.saturation,
+                'saturation');
+  assert_equals(settings.sharpness,
+                clonedSettings.sharpness,
+                'sharpness');
+
+  assert_equals(settings.focusDistance,
+                clonedSettings.focusDistance,
+                'focusDistance');
+
+  assert_equals(settings.pan,
+                clonedSettings.pan,
+                'pan');
+  assert_equals(settings.tilt,
+                clonedSettings.tilt,
+                'tilt');
+  assert_equals(settings.zoom,
+                clonedSettings.zoom,
+                'zoom');
+
+  assert_equals(settings.torch,
+                clonedSettings.torch,
+                'torch');
+}, 'checks MediaStreamTrack.clone() gets same settings');
+
+// This test verifies that MediaStreamTrack ImageCapture capabilities are copied
+// when cloning a MediaStreamTrack.
+image_capture_test(async (t, imageCaptureTest) => {
+  await test_driver.set_permission({name: 'camera', panTiltZoom: true},
+      'granted', false);
+
+  let stream = await navigator.mediaDevices.getUserMedia({video: true});
+  let originalVideoTrack = stream.getVideoTracks()[0];
+  let clonedVideoTrack = originalVideoTrack.clone();
+
+  let capabilities = originalVideoTrack.getCapabilities();
+  let clonedCapabilities = clonedVideoTrack.getCapabilities();
+
+  assert_equals(capabilities.whiteBalanceMode.length,
+                clonedCapabilities.whiteBalanceMode.length,
+                'whiteBalanceMode length');
+  for (i = 0; i < capabilities.whiteBalanceMode.length; ++i) {
+    assert_equals(capabilities.whiteBalanceMode[i],
+                  clonedCapabilities.whiteBalanceMode[i],
+                  'whiteBalanceMode');
+  }
+
+  assert_equals(capabilities.exposureMode.length,
+                clonedCapabilities.exposureMode.length,
+                'exposureMode length');
+  for (i = 0; i < capabilities.exposureMode.length; ++i) {
+    assert_equals(capabilities.exposureMode[i],
+                  clonedCapabilities.exposureMode[i],
+                  'exposureMode');
+  }
+
+  assert_equals(capabilities.focusMode.length,
+                clonedCapabilities.focusMode.length,
+                'focusMode length');
+  for (i = 0; i < capabilities.focusMode.length; ++i) {
+    assert_equals(capabilities.focusMode[i],
+                  clonedCapabilities.focusMode[i],
+                  'focusMode');
+  }
+
+  assert_equals(capabilities.exposureCompensation.max,
+                clonedCapabilities.exposureCompensation.max,
+                'exposureCompensation max');
+  assert_equals(capabilities.exposureCompensation.min,
+                clonedCapabilities.exposureCompensation.min,
+                'exposureCompensation min');
+  assert_equals(capabilities.exposureCompensation.step,
+                clonedCapabilities.exposureCompensation.step,
+                'exposureCompensation step');
+
+  assert_equals(capabilities.exposureTime.max,
+                clonedCapabilities.exposureTime.max,
+                'exposureTime max');
+  assert_equals(capabilities.exposureTime.min,
+                clonedCapabilities.exposureTime.min,
+                'exposureTime min');
+  assert_equals(capabilities.exposureTime.step,
+                clonedCapabilities.exposureTime.step,
+                'exposureTime step');
+
+  assert_equals(capabilities.colorTemperature.max,
+                clonedCapabilities.colorTemperature.max,
+                'colorTemperature max');
+  assert_equals(capabilities.colorTemperature.min,
+                clonedCapabilities.colorTemperature.min,
+                'colorTemperature min');
+  assert_equals(capabilities.colorTemperature.step,
+                clonedCapabilities.colorTemperature.step,
+                'colorTemperature step');
+
+  assert_equals(capabilities.iso.max,
+                clonedCapabilities.iso.max,
+                'iso max');
+  assert_equals(capabilities.iso.min,
+                clonedCapabilities.iso.min,
+                'iso min');
+  assert_equals(capabilities.iso.step,
+                clonedCapabilities.iso.step,
+                'iso step');
+
+  assert_equals(capabilities.brightness.max,
+                clonedCapabilities.brightness.max,
+                'brightness max');
+  assert_equals(capabilities.brightness.min,
+                clonedCapabilities.brightness.min,
+                'brightness min');
+  assert_equals(capabilities.brightness.step,
+                clonedCapabilities.brightness.step,
+                'brightness step');
+
+  assert_equals(capabilities.contrast.max,
+                clonedCapabilities.contrast.max,
+                'contrast max');
+  assert_equals(capabilities.contrast.min,
+                clonedCapabilities.contrast.min,
+                'contrast min');
+  assert_equals(capabilities.contrast.step,
+                clonedCapabilities.contrast.step,
+                'contrast step');
+
+  assert_equals(capabilities.saturation.max,
+                clonedCapabilities.saturation.max,
+                'saturation max');
+  assert_equals(capabilities.saturation.min,
+                clonedCapabilities.saturation.min,
+                'saturation min');
+  assert_equals(capabilities.saturation.step,
+                clonedCapabilities.saturation.step,
+                'saturation step');
+
+  assert_equals(capabilities.sharpness.max,
+                clonedCapabilities.sharpness.max,
+                'sharpness max');
+  assert_equals(capabilities.sharpness.min,
+                clonedCapabilities.sharpness.min,
+                'sharpness min');
+  assert_equals(capabilities.sharpness.step,
+                clonedCapabilities.sharpness.step,
+                'sharpness step');
+
+  assert_equals(capabilities.focusDistance.max,
+                clonedCapabilities.focusDistance.max,
+                'focusDistance max');
+  assert_equals(capabilities.focusDistance.min,
+                clonedCapabilities.focusDistance.min,
+                'focusDistance min');
+  assert_equals(capabilities.focusDistance.step,
+                clonedCapabilities.focusDistance.step,
+                'focusDistance step');
+
+  assert_equals(capabilities.pan.max,
+                clonedCapabilities.pan.max,
+                'pan max');
+  assert_equals(capabilities.pan.min,
+                clonedCapabilities.pan.min,
+                'pan min');
+  assert_equals(capabilities.pan.step,
+                clonedCapabilities.pan.step,
+                'pan step');
+
+  assert_equals(capabilities.tilt.max,
+                clonedCapabilities.tilt.max,
+                'tilt max');
+  assert_equals(capabilities.tilt.min,
+                clonedCapabilities.tilt.min,
+                'tilt min');
+  assert_equals(capabilities.tilt.step,
+                clonedCapabilities.tilt.step,
+                'tilt step');
+
+  assert_equals(capabilities.zoom.max,
+                clonedCapabilities.zoom.max,
+                'zoom max');
+  assert_equals(capabilities.zoom.min,
+                clonedCapabilities.zoom.min,
+                'zoom min');
+  assert_equals(capabilities.zoom.step,
+                clonedCapabilities.zoom.step,
+                'zoom step');
+
+  assert_equals(capabilities.torch,
+                clonedCapabilities.torch,
+                'torch');
+}, 'checks MediaStreamTrack.clone() gets same capabilities');
+</script>