<!DOCTYPE html>
<script src="../resources/testharness.js"></script>
<script src="../resources/testharnessreport.js"></script>
<script src="../resources/mojo-helpers.js"></script>
<script src="resources/mock-imagecapture.js"></script>
<body>
<canvas id='canvas' width=10 height=10/>
</body>
<script>

const meteringModeNames = ["none", "manual", "single-shot", "continuous"];

// This test verifies that MediaTrackCapabilities are returned upon
// MediaStreamTrack.getCapabilities(), with a mock Mojo service implementation.

async_test(function(t) {
  var canvas = document.getElementById('canvas');
  var context = canvas.getContext("2d");
  context.fillStyle = "red";
  context.fillRect(0, 0, 10, 10);

  var mock_capabilities;
  mockImageCaptureReady
    .then(mock => {
      mock_capabilities = mock.capabilities();

      // |stream| must be created _after_ |mock| is constructed to give the
      // latter time to override the bindings.
      var stream = canvas.captureStream();
      assert_equals(stream.getAudioTracks().length, 0);
      assert_equals(stream.getVideoTracks().length, 1);

      var videoTrack = stream.getVideoTracks()[0];
      assert_equals(typeof videoTrack.getCapabilities, 'function');

      // |videoTrack|s capabilities, just like the actual capture, is a process
      // kicked right after creation, we introduce a small delay to allow for
      // those to be collected.
      setTimeout(() => {
        capabilities = videoTrack.getCapabilities();
        assert_equals(typeof capabilities, 'object');

        assert_equals(capabilities.whiteBalanceMode.length,
                      mock_capabilities.supported_white_balance_modes.length,
                      'whiteBalanceMode');
        for (i = 0; i < capabilities.whiteBalanceMode.length; ++i) {
          assert_equals(
              capabilities.whiteBalanceMode[i],
              meteringModeNames[mock_capabilities
                                    .supported_white_balance_modes[i]],
              'whiteBalanceMode');
        }

        assert_equals(capabilities.exposureMode.length,
                      mock_capabilities.supported_exposure_modes.length,
                      'exposureMode');
        for (i = 0; i < capabilities.exposureMode.length; ++i) {
          assert_equals(
              capabilities.exposureMode[i],
              meteringModeNames[mock_capabilities.supported_exposure_modes[i]],
              'exposureMode');
        }

        assert_equals(capabilities.focusMode.length,
                      mock_capabilities.supported_focus_modes.length,
                      'focusMode');
        for (i = 0; i < capabilities.focusMode.length; ++i) {
          assert_equals(
              capabilities.focusMode[i],
              meteringModeNames[mock_capabilities.supported_focus_modes[i]],
              'focusMode');
        }

        assert_true(capabilities.exposureCompensation instanceof
                    MediaSettingsRange);
        assert_equals(capabilities.exposureCompensation.max,
                      mock_capabilities.exposure_compensation.max);
        assert_equals(capabilities.exposureCompensation.min,
                      mock_capabilities.exposure_compensation.min);
        assert_equals(capabilities.exposureCompensation.step,
                      mock_capabilities.exposure_compensation.step);

        assert_true(capabilities.colorTemperature instanceof
                    MediaSettingsRange);
        assert_equals(capabilities.colorTemperature.max,
                      mock_capabilities.color_temperature.max);
        assert_equals(capabilities.colorTemperature.min,
                      mock_capabilities.color_temperature.min);
        assert_equals(capabilities.colorTemperature.step,
                      mock_capabilities.color_temperature.step);

        assert_true(capabilities.iso instanceof MediaSettingsRange);
        assert_equals(capabilities.iso.max, mock_capabilities.iso.max);
        assert_equals(capabilities.iso.min, mock_capabilities.iso.min);
        assert_equals(capabilities.iso.step, mock_capabilities.iso.step);

        assert_true(capabilities.brightness instanceof MediaSettingsRange);
        assert_equals(capabilities.brightness.max,
                      mock_capabilities.brightness.max);
        assert_equals(capabilities.brightness.min,
                      mock_capabilities.brightness.min);
        assert_equals(capabilities.brightness.step,
                      mock_capabilities.brightness.step);

        assert_true(capabilities.contrast instanceof MediaSettingsRange);
        assert_equals(capabilities.contrast.max,
                      mock_capabilities.contrast.max);
        assert_equals(capabilities.contrast.min,
                      mock_capabilities.contrast.min);
        assert_equals(capabilities.contrast.step,
                      mock_capabilities.contrast.step);

        assert_true(capabilities.saturation instanceof MediaSettingsRange);
        assert_equals(capabilities.saturation.max,
                      mock_capabilities.saturation.max);
        assert_equals(capabilities.saturation.min,
                      mock_capabilities.saturation.min);
        assert_equals(capabilities.saturation.step,
                      mock_capabilities.saturation.step);

        assert_true(capabilities.sharpness instanceof MediaSettingsRange);
        assert_equals(capabilities.sharpness.max,
                      mock_capabilities.sharpness.max);
        assert_equals(capabilities.sharpness.min,
                      mock_capabilities.sharpness.min);
        assert_equals(capabilities.sharpness.step,
                      mock_capabilities.sharpness.step);

        assert_true(capabilities.zoom instanceof MediaSettingsRange);
        assert_equals(capabilities.zoom.max, mock_capabilities.zoom.max);
        assert_equals(capabilities.zoom.min, mock_capabilities.zoom.min);
        assert_equals(capabilities.zoom.step, mock_capabilities.zoom.step);

        assert_equals(capabilities.torch, mock_capabilities.supports_torch,
                      'torch');

        t.done();
      }, 100);
    },
    error => {
      assert_unreached("Error creating MockImageCapture: " + error);
    })

}, 'exercises MediaStreamTrack.getCapabilities()');

</script>