[Image Capture] Add browser_tests for focusDistance constraint.

This is a JavaScript based test which is skipped if focusDistance is not
supported. This test is run both on real cameras on some bots and also
against the FakeVideoCaptureDevice.

BUG=732807

Change-Id: I87be1cbf96aa79adcd539732f421bcfe69f92981
Reviewed-on: https://chromium-review.googlesource.com/c/1306498
Commit-Queue: Rijubrata Bhaumik <rijubrata.bhaumik@intel.com>
Reviewed-by: Miguel Casas <mcasas@chromium.org>
Cr-Commit-Position: refs/heads/master@{#604186}

content/browser/webrtc/webrtc_image_capture_browsertest.cc

@@ -34,6 +34,7 @@ namespace content {
 #define MAYBE_GetTrackSettings GetTrackSettings
 #define MAYBE_ManipulateZoom DISABLED_ManipulateZoom
 #define MAYBE_ManipulateExposureTime DISABLED_ManipulateExposureTime
+#define MAYBE_ManipulateFocusDistance DISABLED_ManipulateFocusDistance
 #else
 #define MAYBE_GetPhotoCapabilities GetPhotoCapabilities
 #define MAYBE_GetPhotoSettings GetPhotoSettings
@@ -43,6 +44,7 @@ namespace content {
 #define MAYBE_GetTrackSettings GetTrackSettings
 #define MAYBE_ManipulateZoom ManipulateZoom
 #define MAYBE_ManipulateExposureTime ManipulateExposureTime
+#define MAYBE_ManipulateFocusDistance ManipulateFocusDistance
 #endif
 
 namespace {
@@ -235,6 +237,12 @@ IN_PROC_BROWSER_TEST_P(WebRtcImageCaptureSucceedsBrowserTest,
   ASSERT_TRUE(RunImageCaptureTestCase("testManipulateExposureTime()"));
 }
 
+IN_PROC_BROWSER_TEST_P(WebRtcImageCaptureSucceedsBrowserTest,
+                       MAYBE_ManipulateFocusDistance) {
+  embedded_test_server()->StartAcceptingConnections();
+  ASSERT_TRUE(RunImageCaptureTestCase("testManipulateFocusDistance()"));
+}
+
 INSTANTIATE_TEST_CASE_P(
     ,  // Use no prefix, so that these get picked up when using
        // --gtest_filter=WebRtc*

content/test/data/media/image_capture_test.html

@@ -271,6 +271,68 @@ function testManipulateExposureTime() {
         });
 }
 
+// Tries to read, set and read back the focusDistance capability if available.
+function testManipulateFocusDistance() {
+    var newFocusDistance = -1;
+    var imageCapturer;
+    var focusDistanceTolerance;
+    navigator.mediaDevices.getUserMedia({"video": CONSTRAINTS})
+        .then(stream => {
+            assertEquals('video', stream.getVideoTracks()[0].kind);
+            return new ImageCapture(stream.getVideoTracks()[0]);
+        })
+        .then(capturer => {
+            imageCapturer = capturer;
+            // TODO(mcasas): Before accesing synchronous track APIs we need a delay,
+            // use instead a round trip of capabilities: https://crbug.com/711524.
+            return capturer.getPhotoCapabilities();
+        })
+        .then(capabilities => {
+            const trackCapabilities = imageCapturer.track.getCapabilities();
+            if (trackCapabilities.focusDistance === undefined) {
+                console.log('focusDistance not supported, skipping test');
+                reportTestSuccess();
+                return;
+            }
+
+            const currentFocusDistance = imageCapturer.track.getSettings().focusDistance;
+            newFocusDistance = currentFocusDistance + trackCapabilities.focusDistance
+                .step;
+            newFocusDistance = Math.min(newFocusDistance, trackCapabilities.focusDistance
+                .max);
+            console.log("Setting focusDistance from " + currentFocusDistance +
+                " to " +
+                newFocusDistance);
+            focusDistanceTolerance = trackCapabilities.focusDistance.step /
+                10;
+
+            currentFocusMode = imageCapturer.track.getSettings().focusMode;
+            console.log(" focusMode == " + currentFocusMode);
+            focusModeCapabilities = trackCapabilities.focusMode;
+            console.log(" focusModeCapabilities == " +
+                focusModeCapabilities);
+
+            return imageCapturer.track.applyConstraints({
+                advanced: [{
+                    focusMode: "manual",
+                    focusDistance: newFocusDistance
+                }]
+            });
+        })
+        .then(() => {
+            assertEquals(newFocusDistance,
+                imageCapturer.track.getConstraints().advanced[0].focusDistance
+            );
+            assertTrue(Math.abs(newFocusDistance - imageCapturer.track.getSettings()
+                    .focusDistance) <
+                focusDistanceTolerance);
+            reportTestSuccess();
+        })
+        .catch(err => {
+            return failTest(err.toString());
+        });
+}
+
 </script>
 </body>
 </html>

media/capture/video/fake_video_capture_device.cc

@@ -46,6 +46,10 @@ static const double kMinExposureTime = 10.0;
 static const double kMaxExposureTime = 100.0;
 static const double kExposureTimeStep = 5.0;
 
+static const double kMinFocusDistance = 10.0;
+static const double kMaxFocusDistance = 100.0;
+static const double kFocusDistanceStep = 5.0;
+
 // Larger int means better.
 enum class PixelFormatMatchType : int {
   INCOMPATIBLE = 0,
@@ -466,7 +470,6 @@ void FakePhotoDevice::GetPhotoState(
   photo_state->supported_exposure_modes.push_back(
       mojom::MeteringMode::CONTINUOUS);
   photo_state->current_exposure_mode = fake_device_state_->exposure_mode;
-  photo_state->current_focus_mode = mojom::MeteringMode::NONE;
 
   photo_state->exposure_compensation = mojom::Range::New();
 
@@ -488,11 +491,15 @@ void FakePhotoDevice::GetPhotoState(
   photo_state->saturation = media::mojom::Range::New();
   photo_state->sharpness = media::mojom::Range::New();
 
+  photo_state->supported_focus_modes.push_back(mojom::MeteringMode::MANUAL);
+  photo_state->supported_focus_modes.push_back(mojom::MeteringMode::CONTINUOUS);
+  photo_state->current_focus_mode = fake_device_state_->focus_mode;
+
   photo_state->focus_distance = mojom::Range::New();
-  photo_state->focus_distance->current = 3.0;
-  photo_state->focus_distance->max = 5.0;
-  photo_state->focus_distance->min = 1.0;
-  photo_state->focus_distance->step = 1.0;
+  photo_state->focus_distance->current = fake_device_state_->focus_distance;
+  photo_state->focus_distance->max = kMaxFocusDistance;
+  photo_state->focus_distance->min = kMinFocusDistance;
+  photo_state->focus_distance->step = kFocusDistanceStep;
 
   photo_state->zoom = mojom::Range::New();
   photo_state->zoom->current = fake_device_state_->zoom;
@@ -541,6 +548,12 @@ void FakePhotoDevice::SetPhotoOptions(
         kMinExposureTime, std::min(settings->exposure_time, kMaxExposureTime));
   }
 
+  if (settings->has_focus_distance) {
+    device_state_write_access->focus_distance =
+        std::max(kMinFocusDistance,
+                 std::min(settings->focus_distance, kMaxFocusDistance));
+  }
+
   std::move(callback).Run(true);
 }
 

media/capture/video/fake_video_capture_device.h

@@ -104,18 +104,24 @@ class FakeVideoCaptureDevice : public VideoCaptureDevice {
 struct FakeDeviceState {
   FakeDeviceState(float zoom,
                   float exposure_time,
+                  float focus_distance,
                   float frame_rate,
                   VideoPixelFormat pixel_format)
       : zoom(zoom),
         exposure_time(exposure_time),
+        focus_distance(focus_distance),
         format(gfx::Size(), frame_rate, pixel_format) {
     exposure_mode = (exposure_time >= 0.0f) ? mojom::MeteringMode::MANUAL
                                             : mojom::MeteringMode::CONTINUOUS;
+    focus_mode = (focus_distance >= 0.0f) ? mojom::MeteringMode::MANUAL
+                                          : mojom::MeteringMode::CONTINUOUS;
   }
 
   uint32_t zoom;
   uint32_t exposure_time;
   mojom::MeteringMode exposure_mode;
+  uint32_t focus_distance;
+  mojom::MeteringMode focus_mode;
   VideoCaptureFormat format;
 };
 

media/capture/video/fake_video_capture_device_factory.cc

@@ -37,6 +37,7 @@ static constexpr std::array<float, 1> kDefaultFrameRates{{20.0f}};
 
 static const double kInitialZoom = 100.0;
 static const double kInitialExposureTime = 50.0;
+static const double kInitialFocusDistance = 50.0;
 
 static const media::VideoPixelFormat kSupportedPixelFormats[] = {
     media::PIXEL_FORMAT_I420, media::PIXEL_FORMAT_Y16,
@@ -134,8 +135,8 @@ FakeVideoCaptureDeviceFactory::CreateDeviceWithSettings(
 
   const VideoCaptureFormat& initial_format = settings.supported_formats.front();
   auto device_state = std::make_unique<FakeDeviceState>(
-      kInitialZoom, kInitialExposureTime, initial_format.frame_rate,
-      initial_format.pixel_format);
+      kInitialZoom, kInitialExposureTime, kInitialFocusDistance,
+      initial_format.frame_rate, initial_format.pixel_format);
 
   auto photo_frame_painter = std::make_unique<PacmanFramePainter>(
       PacmanFramePainter::Format::SK_N32, device_state.get());

media/capture/video/fake_video_capture_device_unittest.cc

@@ -364,7 +364,7 @@ TEST_F(FakeVideoCaptureDeviceTest, GetAndSetCapabilities) {
   ASSERT_TRUE(state);
   EXPECT_EQ(mojom::MeteringMode::NONE, state->current_white_balance_mode);
   EXPECT_EQ(mojom::MeteringMode::MANUAL, state->current_exposure_mode);
-  EXPECT_EQ(mojom::MeteringMode::NONE, state->current_focus_mode);
+  EXPECT_EQ(mojom::MeteringMode::MANUAL, state->current_focus_mode);
 
   EXPECT_EQ(0, state->exposure_compensation->min);
   EXPECT_EQ(0, state->exposure_compensation->max);
@@ -403,10 +403,10 @@ TEST_F(FakeVideoCaptureDeviceTest, GetAndSetCapabilities) {
   EXPECT_FALSE(state->supports_torch);
   EXPECT_FALSE(state->torch);
 
-  EXPECT_EQ(1.0, state->focus_distance->min);
-  EXPECT_EQ(5.0, state->focus_distance->max);
-  EXPECT_EQ(3.0, state->focus_distance->current);
-  EXPECT_EQ(1.0, state->focus_distance->step);
+  EXPECT_EQ(10, state->focus_distance->min);
+  EXPECT_EQ(100, state->focus_distance->max);
+  EXPECT_EQ(50, state->focus_distance->current);
+  EXPECT_EQ(5, state->focus_distance->step);
 
   EXPECT_EQ(mojom::RedEyeReduction::NEVER, state->red_eye_reduction);
   EXPECT_EQ(capture_params.requested_format.frame_size.height(),