diff --git a/media/capture/video/mac/video_capture_device_avfoundation_mac.h b/media/capture/video/mac/video_capture_device_avfoundation_mac.h
index ec48e672..d9d2217 100644
--- a/media/capture/video/mac/video_capture_device_avfoundation_mac.h
+++ b/media/capture/video/mac/video_capture_device_avfoundation_mac.h
@@ -81,7 +81,8 @@
 // "next generation" moniker.
 CAPTURE_EXPORT
 @interface VideoCaptureDeviceAVFoundation
-    : NSObject <AVCaptureVideoDataOutputSampleBufferDelegate> {
+    : NSObject <AVCaptureVideoDataOutputSampleBufferDelegate,
+                AVCapturePhotoCaptureDelegate> {
  @private
   // The following attributes are set via -setCaptureHeight:width:frameRate:.
   int _frameWidth;
@@ -130,17 +131,20 @@
   std::vector<std::unique_ptr<media::SampleBufferTransformer>>
       _scaledFrameTransformers;
 
-  // An AVDataOutput specialized for taking pictures out of |captureSession_|.
-  base::scoped_nsobject<AVCaptureStillImageOutput> _stillImageOutput;
-  size_t _takePhotoStartedCount;
-  size_t _takePhotoPendingCount;
-  size_t _takePhotoCompletedCount;
-  bool _stillImageOutputWarmupCompleted;
+  // On macOS 10.15 or later, this has type AVCapturePhotoOutput.
+  // On earlier versions, this has type AVCaptureStillImageOutput.
+  // You say tomato, I say potato.
+  base::scoped_nsobject<id> _photoOutput;
+  // Only accessed on the main thread. The takePhoto() operation is considered
+  // pending until we're ready to take another photo, which involves a PostTask
+  // back to the main thread after the photo was taken.
+  size_t _pendingTakePhotos;
   std::unique_ptr<base::WeakPtrFactory<VideoCaptureDeviceAVFoundation>>
       _weakPtrFactoryForTakePhoto;
 
   // For testing.
-  base::RepeatingCallback<void()> _onStillImageOutputStopped;
+  base::RepeatingCallback<void()> _onPhotoOutputStopped;
+  bool _forceLegacyStillImageApi;
 
   scoped_refptr<base::SingleThreadTaskRunner> _mainThreadTaskRunner;
 }
@@ -206,8 +210,9 @@
 // formats. This implementation recognizes NV12.
 + (media::VideoPixelFormat)FourCCToChromiumPixelFormat:(FourCharCode)code;
 
-- (void)setOnStillImageOutputStoppedForTesting:
-    (base::RepeatingCallback<void()>)onStillImageOutputStopped;
+- (void)setOnPhotoOutputStoppedForTesting:
+    (base::RepeatingCallback<void()>)onPhotoOutputStopped;
+- (void)setForceLegacyStillImageApiForTesting:(bool)forceLegacyApi;
 
 // Use the below only for test.
 - (void)callLocked:(base::OnceClosure)lambda;
diff --git a/media/capture/video/mac/video_capture_device_avfoundation_mac.mm b/media/capture/video/mac/video_capture_device_avfoundation_mac.mm
index 82b18a8f..fa936dc 100644
--- a/media/capture/video/mac/video_capture_device_avfoundation_mac.mm
+++ b/media/capture/video/mac/video_capture_device_avfoundation_mac.mm
@@ -43,7 +43,7 @@
     gfx::ColorSpace::MatrixID::SMPTE170M,
     gfx::ColorSpace::RangeID::LIMITED);
 
-constexpr int kTimeToWaitBeforeStoppingStillImageCaptureInSeconds = 60;
+constexpr int kTimeToWaitBeforeStoppingPhotoOutputInSeconds = 60;
 constexpr FourCharCode kDefaultFourCCPixelFormat =
     kCVPixelFormatType_420YpCbCr8BiPlanarVideoRange;  // NV12 (a.k.a. 420v)
 
@@ -197,10 +197,10 @@
 }
 
 - (void)dealloc {
-  // Stopping a running still image output takes `_lock`. To avoid this
-  // happening inside stopCapture() below which would deadlock, we ensure that
-  // still image output is already stopped before taking `_lock`.
-  [self stopStillImageOutput];
+  // Stopping a running photo output takes `_lock`. To avoid this happening
+  // inside stopCapture() below which would deadlock, we ensure that the photo
+  // output is already stopped before taking `_lock`.
+  [self stopPhotoOutput];
   {
     // To avoid races with concurrent callbacks, grab the lock before stopping
     // capture and clearing all the variables.
@@ -239,7 +239,7 @@
     [self stopCapture];
     // Now remove the input and output from the capture session.
     [_captureSession removeOutput:_captureVideoDataOutput];
-    [self stopStillImageOutput];
+    [self stopPhotoOutput];
     if (_captureDeviceInput) {
       DCHECK(_captureDevice);
       [_captureSession stopRunning];
@@ -449,93 +449,101 @@
 - (void)stopCapture {
   DCHECK(_mainThreadTaskRunner->BelongsToCurrentThread());
   _weakPtrFactoryForStallCheck.reset();
-  [self stopStillImageOutput];
+  [self stopPhotoOutput];
   if ([_captureSession isRunning])
     [_captureSession stopRunning];  // Synchronous.
   [[NSNotificationCenter defaultCenter] removeObserver:self];
 }
 
+- (bool)useLegacyStillImageApi {
+  if (@available(macOS 10.15, *)) {
+    return _forceLegacyStillImageApi;
+  }
+  return true;
+}
+
+- (void)setForceLegacyStillImageApiForTesting:(bool)forceLegacyApi {
+  _forceLegacyStillImageApi = forceLegacyApi;
+}
+
 - (void)takePhoto {
   DCHECK(_mainThreadTaskRunner->BelongsToCurrentThread());
   DCHECK([_captureSession isRunning]);
 
-  ++_takePhotoStartedCount;
+  ++_pendingTakePhotos;
+  if (_pendingTakePhotos > 1u) {
+    // There is already pending takePhoto(). When it finishes it will kick off
+    // the next takePhotoInternal(), so there is nothing more to do here.
+    return;
+  }
+  // `_pendingTakePhotos` just went from 0 to 1. In case the 60 second delayed
+  // task to perform stopPhotoOutput() is in-flight, invalidate weak ptrs to
+  // cancel any such operation.
+  _weakPtrFactoryForTakePhoto->InvalidateWeakPtrs();
 
   // Ready to take a photo immediately?
-  if (_stillImageOutput && _stillImageOutputWarmupCompleted) {
+  // Thread-safe because `_photoOutput` is only modified on the main thread.
+  if (_photoOutput) {
     [self takePhotoInternal];
     return;
   }
 
-  // Lazily instantiate the |_stillImageOutput| the first time takePhoto() is
-  // called. When takePhoto() isn't called, this avoids JPEG compession work for
-  // every frame. This can save a lot of CPU in some cases (see
-  // https://crbug.com/1116241). However because it can take a couple of second
-  // for the 3A to stabilize, lazily instantiating like may result in noticeable
-  // delays. To avoid delays in future takePhoto() calls we don't delete
-  // |_stillImageOutput| until takePhoto() has not been called for 60 seconds.
-  if (!_stillImageOutput) {
-    // We use AVCaptureStillImageOutput for historical reasons, but note that it
-    // has been deprecated in macOS 10.15[1] in favor of
-    // AVCapturePhotoOutput[2].
-    //
-    // [1]
-    // https://developer.apple.com/documentation/avfoundation/avcapturestillimageoutput
-    // [2]
-    // https://developer.apple.com/documentation/avfoundation/avcapturephotooutput
-    // TODO(https://crbug.com/1124322): Migrate to the new API.
-    _stillImageOutput.reset([[AVCaptureStillImageOutput alloc] init]);
-    if (!_stillImageOutput ||
-        ![_captureSession canAddOutput:_stillImageOutput]) {
-      // Complete this started photo as error.
-      ++_takePhotoPendingCount;
-      {
-        base::AutoLock lock(_lock);
-        if (_frameReceiver) {
-          _frameReceiver->OnPhotoError();
-        }
-      }
-      [self takePhotoCompleted];
-      return;
+  // Lazily instantiate `_photoOutput` so that if the app never calls
+  // takePhoto() we don't have to pay the associated performance cost, see
+  // https://crbug.com/1116241. This procedure is purposefully delayed by 3
+  // seconds because the camera needs to ramp up after re-configuring itself in
+  // order for 3A to stabilize or else the photo is dark/black.
+  {
+    // `_lock` is needed since `_photoOutput` may be read from non-main thread.
+    base::AutoLock lock(_lock);
+    if ([self useLegacyStillImageApi]) {
+      _photoOutput.reset([[AVCaptureStillImageOutput alloc] init]);
+    } else if (@available(macOS 10.15, *)) {
+      _photoOutput.reset([[AVCapturePhotoOutput alloc] init]);
+    } else {
+      NOTREACHED();
     }
-    [_captureSession addOutput:_stillImageOutput];
-    // A delay is needed before taking the photo or else the photo may be dark.
-    // 2 seconds was enough in manual testing; we delay by 3 for good measure.
-    _mainThreadTaskRunner->PostDelayedTask(
-        FROM_HERE,
-        base::BindOnce(
-            [](base::WeakPtr<VideoCaptureDeviceAVFoundation> weakSelf) {
-              [weakSelf.get() takePhotoInternal];
-            },
-            _weakPtrFactoryForTakePhoto->GetWeakPtr()),
-        base::Seconds(3));
   }
+  if (![_captureSession canAddOutput:_photoOutput]) {
+    {
+      base::AutoLock lock(_lock);
+      if (_frameReceiver) {
+        _frameReceiver->OnPhotoError();
+      }
+    }
+    [self takePhotoResolved];
+    return;
+  } else {
+    [_captureSession addOutput:_photoOutput];
+  }
+  // A delay is needed before taking the photo or else the photo may be dark.
+  // 2 seconds was enough in manual testing; we delay by 3 for good measure.
+  _mainThreadTaskRunner->PostDelayedTask(
+      FROM_HERE,
+      base::BindOnce(
+          [](base::WeakPtr<VideoCaptureDeviceAVFoundation> weakSelf) {
+            [weakSelf.get() takePhotoInternal];
+          },
+          _weakPtrFactoryForTakePhoto->GetWeakPtr()),
+      base::Seconds(3));
 }
 
-- (void)setOnStillImageOutputStoppedForTesting:
-    (base::RepeatingCallback<void()>)onStillImageOutputStopped {
+- (void)setOnPhotoOutputStoppedForTesting:
+    (base::RepeatingCallback<void()>)onPhotoOutputStopped {
   DCHECK(_mainThreadTaskRunner->BelongsToCurrentThread());
-  _onStillImageOutputStopped = onStillImageOutputStopped;
+  _onPhotoOutputStopped = onPhotoOutputStopped;
 }
 
 #pragma mark Private methods
 
 - (void)takePhotoInternal {
   DCHECK(_mainThreadTaskRunner->BelongsToCurrentThread());
-  // stopStillImageOutput invalidates all weak ptrs, meaning in-flight
-  // operations are affectively cancelled. So if this method is running, still
-  // image output must be good to go.
   DCHECK([_captureSession isRunning]);
-  DCHECK(_stillImageOutput);
-  DCHECK([[_stillImageOutput connections] count] == 1);
-  AVCaptureConnection* const connection =
-      [[_stillImageOutput connections] firstObject];
-  DCHECK(connection);
-  _stillImageOutputWarmupCompleted = true;
-
-  // For all photos started that are not yet pending, take photos.
-  while (_takePhotoPendingCount < _takePhotoStartedCount) {
-    ++_takePhotoPendingCount;
+  // takePhotoInternal() can only happen when we have a `_photoOutput` because
+  // stopPhotoOutput() cancels in-flight operations by invalidating weak ptrs.
+  DCHECK(_photoOutput);
+  if ([self useLegacyStillImageApi]) {
+    // `_photoOutput` is of type AVCaptureStillImageOutput.
     const auto handler = ^(CMSampleBufferRef sampleBuffer, NSError* error) {
       {
         base::AutoLock lock(_lock);
@@ -552,7 +560,6 @@
             DCHECK_EQ(kCMVideoCodecType_JPEG,
                       CMFormatDescriptionGetMediaSubType(
                           CMSampleBufferGetFormatDescription(sampleBuffer)));
-
             char* baseAddress = 0;
             size_t length = 0;
             const bool sample_buffer_addressable =
@@ -567,75 +574,139 @@
           }
         }
       }
-      // Called both on success and failure.
+      // Whether we succeeded or failed, we need to resolve the pending
+      // takePhoto() operation.
       _mainThreadTaskRunner->PostTask(
           FROM_HERE,
           base::BindOnce(
               [](base::WeakPtr<VideoCaptureDeviceAVFoundation> weakSelf) {
-                [weakSelf.get() takePhotoCompleted];
+                [weakSelf.get() takePhotoResolved];
               },
               _weakPtrFactoryForTakePhoto->GetWeakPtr()));
     };
-    [_stillImageOutput captureStillImageAsynchronouslyFromConnection:connection
-                                                   completionHandler:handler];
+    AVCaptureStillImageOutput* image_output =
+        static_cast<AVCaptureStillImageOutput*>(_photoOutput.get());
+    DCHECK([[image_output connections] count] == 1);
+    AVCaptureConnection* const connection =
+        [[image_output connections] firstObject];
+    DCHECK(connection);
+    [image_output captureStillImageAsynchronouslyFromConnection:connection
+                                              completionHandler:handler];
+  } else if (@available(macOS 10.15, *)) {
+    // `_photoOutput` is of type AVCapturePhotoOutput.
+    @try {
+      // Asynchronous success or failure is handled inside
+      // captureOutput:didFinishProcessingPhoto:error on an unknown thread.
+      // Synchronous failures are handled in the catch clause below.
+      [_photoOutput
+          capturePhotoWithSettings:[AVCapturePhotoSettings
+                                       photoSettingsWithFormat:@{
+                                         AVVideoCodecKey : AVVideoCodecTypeJPEG
+                                       }]
+                          delegate:self];
+    } @catch (id exception) {
+      {
+        base::AutoLock lock(_lock);
+        if (_frameReceiver) {
+          _frameReceiver->OnPhotoError();
+        }
+      }
+      [self takePhotoResolved];
+    }
+  } else {
+    NOTREACHED();
   }
 }
 
-- (void)takePhotoCompleted {
-  DCHECK(_mainThreadTaskRunner->BelongsToCurrentThread());
-  ++_takePhotoCompletedCount;
-  if (_takePhotoStartedCount != _takePhotoCompletedCount)
-    return;
-  // All pending takePhoto()s have completed. If no more photos are taken
-  // within 60 seconds, stop still image output to avoid expensive MJPEG
-  // conversions going forward.
-  _mainThreadTaskRunner->PostDelayedTask(
-      FROM_HERE,
-      base::BindOnce(
-          [](base::WeakPtr<VideoCaptureDeviceAVFoundation> weakSelf,
-             size_t takePhotoCount) {
-            VideoCaptureDeviceAVFoundation* strongSelf = weakSelf.get();
-            if (!strongSelf)
-              return;
-            // Don't stop the still image output if takePhoto() was called
-            // while the task was pending.
-            if (strongSelf->_takePhotoStartedCount != takePhotoCount)
-              return;
-            [strongSelf stopStillImageOutput];
-          },
-          _weakPtrFactoryForTakePhoto->GetWeakPtr(), _takePhotoStartedCount),
-      base::Seconds(kTimeToWaitBeforeStoppingStillImageCaptureInSeconds));
-}
-
-- (void)stopStillImageOutput {
-  DCHECK(_mainThreadTaskRunner->BelongsToCurrentThread());
-  if (!_stillImageOutput) {
-    // Already stopped.
-    return;
-  }
-  if (_captureSession) {
-    [_captureSession removeOutput:_stillImageOutput];
-  }
-  _stillImageOutput.reset();
-  _stillImageOutputWarmupCompleted = false;
-
-  // Cancel all in-flight operations.
-  _weakPtrFactoryForTakePhoto->InvalidateWeakPtrs();
-  // Report error for all pending calls that were stopped.
-  size_t pendingCalls = _takePhotoStartedCount - _takePhotoCompletedCount;
-  _takePhotoCompletedCount = _takePhotoPendingCount = _takePhotoStartedCount;
-  {
+// Callback for the `_photoOutput` operation started in takePhotoInternal().
+- (void)captureOutput:(id)output        // AVCapturePhotoOutput*
+    didFinishProcessingPhoto:(id)photo  // AVCapturePhoto*
+                       error:(NSError*)error {
+  if (@available(macOS 10.15, *)) {
     base::AutoLock lock(_lock);
+    // If `output` is no longer current, ignore the result of this operation.
+    // `_frameReceiver->OnPhotoError()` will already have been called inside
+    // stopPhotoOutput().
+    if (output != _photoOutput) {
+      return;
+    }
     if (_frameReceiver) {
-      for (size_t i = 0; i < pendingCalls; ++i) {
+      // Always non-nil according to Apple's documentation.
+      DCHECK(photo);
+      NSData* data = static_cast<AVCapturePhoto*>(photo).fileDataRepresentation;
+      if (!error && data) {
+        _frameReceiver->OnPhotoTaken(
+            reinterpret_cast<const uint8_t*>(data.bytes), data.length,
+            "image/jpeg");
+      } else {
         _frameReceiver->OnPhotoError();
       }
     }
+    // Whether we succeeded or failed, we need to resolve the pending
+    // takePhoto() operation.
+    _mainThreadTaskRunner->PostTask(
+        FROM_HERE,
+        base::BindOnce(
+            [](base::WeakPtr<VideoCaptureDeviceAVFoundation> weakSelf) {
+              [weakSelf.get() takePhotoResolved];
+            },
+            _weakPtrFactoryForTakePhoto->GetWeakPtr()));
+  } else {
+    NOTREACHED();
+  }
+}
+
+- (void)takePhotoResolved {
+  DCHECK(_mainThreadTaskRunner->BelongsToCurrentThread());
+  --_pendingTakePhotos;
+  if (_pendingTakePhotos > 0u) {
+    // Take another photo.
+    [self takePhotoInternal];
+    return;
+  }
+  // All pending takePhoto()s have completed. If no more photos are taken
+  // within 60 seconds, stop photo output to avoid expensive MJPEG conversions
+  // going forward.
+  _mainThreadTaskRunner->PostDelayedTask(
+      FROM_HERE,
+      base::BindOnce(
+          [](base::WeakPtr<VideoCaptureDeviceAVFoundation> weakSelf) {
+            [weakSelf.get() stopPhotoOutput];
+          },
+          _weakPtrFactoryForTakePhoto->GetWeakPtr()),
+      base::Seconds(kTimeToWaitBeforeStoppingPhotoOutputInSeconds));
+}
+
+- (void)stopPhotoOutput {
+  DCHECK(_mainThreadTaskRunner->BelongsToCurrentThread());
+  // Already stopped?
+  // Thread-safe because `_photoOutput` is only modified on the main thread.
+  if (!_photoOutput) {
+    return;
+  }
+  // Cancel all in-flight operations.
+  _weakPtrFactoryForTakePhoto->InvalidateWeakPtrs();
+  {
+    base::AutoLock lock(_lock);
+    if (_captureSession) {
+      [_captureSession removeOutput:_photoOutput];
+    }
+    // `_lock` is needed since `_photoOutput` may be read from non-main thread.
+    _photoOutput.reset();
+    // For every pending photo, report OnPhotoError().
+    if (_pendingTakePhotos) {
+      if (_frameReceiver) {
+        for (size_t i = 0; i < _pendingTakePhotos; ++i) {
+          _frameReceiver->OnPhotoError();
+        }
+      }
+      _pendingTakePhotos = 0u;
+    }
   }
 
-  if (_onStillImageOutputStopped) {
+  if (_onPhotoOutputStopped) {
     // Callback used by tests.
-    _onStillImageOutputStopped.Run();
+    _onPhotoOutputStopped.Run();
   }
 }
 
@@ -893,8 +964,7 @@
     // If we captured a frame since last check, then we aren't stalled.
     // We're also not considered stalled if takePhoto() is pending, avoiding
     // excessive capture restarts in unit tests with mock time.
-    if (_capturedFrameSinceLastStallCheck ||
-        _takePhotoStartedCount != _takePhotoCompletedCount) {
+    if (_capturedFrameSinceLastStallCheck || _pendingTakePhotos) {
       nextFailedCheckCount = 0;
     }
     _capturedFrameSinceLastStallCheck = NO;
diff --git a/media/capture/video/mac/video_capture_device_avfoundation_mac_unittest.mm b/media/capture/video/mac/video_capture_device_avfoundation_mac_unittest.mm
index cb890109..98286d3a 100644
--- a/media/capture/video/mac/video_capture_device_avfoundation_mac_unittest.mm
+++ b/media/capture/video/mac/video_capture_device_avfoundation_mac_unittest.mm
@@ -25,6 +25,9 @@
 #include "ui/gfx/color_space.h"
 
 using testing::_;
+using testing::Gt;
+using testing::Ne;
+using testing::Return;
 
 namespace media {
 
@@ -419,199 +422,228 @@
   }));
 }
 
-TEST(VideoCaptureDeviceAVFoundationMacTest, TakePhoto) {
-  RunTestCase(base::BindOnce([] {
-    NSString* deviceId = GetFirstDeviceId();
-    if (!deviceId) {
-      DVLOG(1) << "No camera available. Exiting test.";
-      return;
-    }
-
-    testing::NiceMock<MockVideoCaptureDeviceAVFoundationFrameReceiver>
-        frame_receiver;
+class VideoCaptureDeviceAVFoundationMacTakePhotoTest
+    : public testing::TestWithParam<bool> {
+ public:
+  base::scoped_nsobject<VideoCaptureDeviceAVFoundation> CreateCaptureDevice(
+      testing::NiceMock<MockVideoCaptureDeviceAVFoundationFrameReceiver>*
+          frame_receiver) {
     base::scoped_nsobject<VideoCaptureDeviceAVFoundation> captureDevice(
         [[VideoCaptureDeviceAVFoundation alloc]
-            initWithFrameReceiver:&frame_receiver]);
+            initWithFrameReceiver:frame_receiver]);
+    [captureDevice setForceLegacyStillImageApiForTesting:GetParam()];
+    return captureDevice;
+  }
+};
 
-    NSString* errorMessage = nil;
-    ASSERT_TRUE([captureDevice setCaptureDevice:deviceId
-                                   errorMessage:&errorMessage]);
-    ASSERT_TRUE([captureDevice startCapture]);
+TEST_P(VideoCaptureDeviceAVFoundationMacTakePhotoTest, TakePhoto) {
+  RunTestCase(base::BindOnce(
+      [](VideoCaptureDeviceAVFoundationMacTakePhotoTest* thiz) {
+        NSString* deviceId = GetFirstDeviceId();
+        if (!deviceId) {
+          DVLOG(1) << "No camera available. Exiting test.";
+          return;
+        }
 
-    base::RunLoop run_loop(base::RunLoop::Type::kNestableTasksAllowed);
-    EXPECT_CALL(frame_receiver, OnPhotoTaken)
-        .WillOnce(base::test::RunClosure(run_loop.QuitClosure()));
-    [captureDevice takePhoto];
-    run_loop.Run();
-  }));
+        testing::NiceMock<MockVideoCaptureDeviceAVFoundationFrameReceiver>
+            frame_receiver;
+        base::scoped_nsobject<VideoCaptureDeviceAVFoundation> captureDevice =
+            thiz->CreateCaptureDevice(&frame_receiver);
+
+        NSString* errorMessage = nil;
+        ASSERT_TRUE([captureDevice setCaptureDevice:deviceId
+                                       errorMessage:&errorMessage]);
+        ASSERT_TRUE([captureDevice startCapture]);
+
+        base::RunLoop run_loop(base::RunLoop::Type::kNestableTasksAllowed);
+        EXPECT_CALL(frame_receiver, OnPhotoTaken)
+
+            .WillOnce([&run_loop](const uint8_t* image_data,
+                                  size_t image_length,
+                                  const std::string& mime_type) {
+              EXPECT_TRUE(image_data);
+              EXPECT_GT(image_length, 0u);
+              EXPECT_EQ(mime_type, "image/jpeg");
+              run_loop.Quit();
+            });
+        [captureDevice takePhoto];
+        run_loop.Run();
+      },
+      this));
 }
 
-TEST(VideoCaptureDeviceAVFoundationMacTest, StopCaptureWhileTakingPhoto) {
-  RunTestCase(base::BindOnce([] {
-    NSString* deviceId = GetFirstDeviceId();
-    if (!deviceId) {
-      DVLOG(1) << "No camera available. Exiting test.";
-      return;
-    }
+TEST_P(VideoCaptureDeviceAVFoundationMacTakePhotoTest,
+       StopCaptureWhileTakingPhoto) {
+  RunTestCase(base::BindOnce(
+      [](VideoCaptureDeviceAVFoundationMacTakePhotoTest* thiz) {
+        NSString* deviceId = GetFirstDeviceId();
+        if (!deviceId) {
+          DVLOG(1) << "No camera available. Exiting test.";
+          return;
+        }
 
-    testing::NiceMock<MockVideoCaptureDeviceAVFoundationFrameReceiver>
-        frame_receiver;
-    base::scoped_nsobject<VideoCaptureDeviceAVFoundation> captureDevice(
-        [[VideoCaptureDeviceAVFoundation alloc]
-            initWithFrameReceiver:&frame_receiver]);
+        testing::NiceMock<MockVideoCaptureDeviceAVFoundationFrameReceiver>
+            frame_receiver;
+        base::scoped_nsobject<VideoCaptureDeviceAVFoundation> captureDevice =
+            thiz->CreateCaptureDevice(&frame_receiver);
 
-    NSString* errorMessage = nil;
-    ASSERT_TRUE([captureDevice setCaptureDevice:deviceId
-                                   errorMessage:&errorMessage]);
-    ASSERT_TRUE([captureDevice startCapture]);
+        NSString* errorMessage = nil;
+        ASSERT_TRUE([captureDevice setCaptureDevice:deviceId
+                                       errorMessage:&errorMessage]);
+        ASSERT_TRUE([captureDevice startCapture]);
 
-    base::RunLoop run_loop(base::RunLoop::Type::kNestableTasksAllowed);
-    EXPECT_CALL(frame_receiver, OnPhotoError())
-        .WillOnce(base::test::RunClosure(run_loop.QuitClosure()));
-    [captureDevice takePhoto];
-    // There is no risk that takePhoto() has successfully finishes before
-    // stopCapture() because the takePhoto() call involes a PostDelayedTask()
-    // that cannot run until RunLoop::Run() below.
-    [captureDevice stopCapture];
-    run_loop.Run();
-  }));
+        base::RunLoop run_loop(base::RunLoop::Type::kNestableTasksAllowed);
+        EXPECT_CALL(frame_receiver, OnPhotoError())
+            .WillOnce(base::test::RunClosure(run_loop.QuitClosure()));
+        [captureDevice takePhoto];
+        // There is no risk that takePhoto() has successfully finishes before
+        // stopCapture() because the takePhoto() call involes a
+        // PostDelayedTask() that cannot run until RunLoop::Run() below.
+        [captureDevice stopCapture];
+        run_loop.Run();
+      },
+      this));
 }
 
-TEST(VideoCaptureDeviceAVFoundationMacTest, MultiplePendingTakePhotos) {
-  RunTestCase(base::BindOnce([] {
-    NSString* deviceId = GetFirstDeviceId();
-    if (!deviceId) {
-      DVLOG(1) << "No camera available. Exiting test.";
-      return;
-    }
+TEST_P(VideoCaptureDeviceAVFoundationMacTakePhotoTest,
+       MultiplePendingTakePhotos) {
+  RunTestCase(base::BindOnce(
+      [](VideoCaptureDeviceAVFoundationMacTakePhotoTest* thiz) {
+        NSString* deviceId = GetFirstDeviceId();
+        if (!deviceId) {
+          DVLOG(1) << "No camera available. Exiting test.";
+          return;
+        }
 
-    testing::NiceMock<MockVideoCaptureDeviceAVFoundationFrameReceiver>
-        frame_receiver;
-    base::scoped_nsobject<VideoCaptureDeviceAVFoundation> captureDevice(
-        [[VideoCaptureDeviceAVFoundation alloc]
-            initWithFrameReceiver:&frame_receiver]);
+        testing::NiceMock<MockVideoCaptureDeviceAVFoundationFrameReceiver>
+            frame_receiver;
+        base::scoped_nsobject<VideoCaptureDeviceAVFoundation> captureDevice =
+            thiz->CreateCaptureDevice(&frame_receiver);
 
-    NSString* errorMessage = nil;
-    ASSERT_TRUE([captureDevice setCaptureDevice:deviceId
-                                   errorMessage:&errorMessage]);
-    ASSERT_TRUE([captureDevice startCapture]);
+        NSString* errorMessage = nil;
+        ASSERT_TRUE([captureDevice setCaptureDevice:deviceId
+                                       errorMessage:&errorMessage]);
+        ASSERT_TRUE([captureDevice startCapture]);
 
-    base::RunLoop run_loop(base::RunLoop::Type::kNestableTasksAllowed);
-    size_t photos_taken_count = 0;
-    EXPECT_CALL(frame_receiver, OnPhotoTaken)
-        .WillRepeatedly([&photos_taken_count, &run_loop] {
-          ++photos_taken_count;
-          if (photos_taken_count == 3) {
-            run_loop.Quit();
-          }
-        });
-    [captureDevice takePhoto];
-    [captureDevice takePhoto];
-    [captureDevice takePhoto];
-    run_loop.Run();
-  }));
+        base::RunLoop run_loop(base::RunLoop::Type::kNestableTasksAllowed);
+        EXPECT_CALL(frame_receiver, OnPhotoTaken(Ne(nullptr), Gt(0u), _))
+            .WillOnce(Return())
+            .WillOnce(Return())
+            .WillOnce(base::test::RunClosure(run_loop.QuitClosure()));
+        [captureDevice takePhoto];
+        [captureDevice takePhoto];
+        [captureDevice takePhoto];
+        run_loop.Run();
+      },
+      this));
 }
 
-TEST(VideoCaptureDeviceAVFoundationMacTest,
-     StopCaptureWhileMultiplePendingTakePhotos) {
-  RunTestCase(base::BindOnce([] {
-    NSString* deviceId = GetFirstDeviceId();
-    if (!deviceId) {
-      DVLOG(1) << "No camera available. Exiting test.";
-      return;
-    }
+TEST_P(VideoCaptureDeviceAVFoundationMacTakePhotoTest,
+       StopCaptureWhileMultiplePendingTakePhotos) {
+  RunTestCase(base::BindOnce(
+      [](VideoCaptureDeviceAVFoundationMacTakePhotoTest* thiz) {
+        NSString* deviceId = GetFirstDeviceId();
+        if (!deviceId) {
+          DVLOG(1) << "No camera available. Exiting test.";
+          return;
+        }
 
-    testing::NiceMock<MockVideoCaptureDeviceAVFoundationFrameReceiver>
-        frame_receiver;
-    base::scoped_nsobject<VideoCaptureDeviceAVFoundation> captureDevice(
-        [[VideoCaptureDeviceAVFoundation alloc]
-            initWithFrameReceiver:&frame_receiver]);
+        testing::NiceMock<MockVideoCaptureDeviceAVFoundationFrameReceiver>
+            frame_receiver;
+        base::scoped_nsobject<VideoCaptureDeviceAVFoundation> captureDevice =
+            thiz->CreateCaptureDevice(&frame_receiver);
 
-    NSString* errorMessage = nil;
-    ASSERT_TRUE([captureDevice setCaptureDevice:deviceId
-                                   errorMessage:&errorMessage]);
-    ASSERT_TRUE([captureDevice startCapture]);
+        NSString* errorMessage = nil;
+        ASSERT_TRUE([captureDevice setCaptureDevice:deviceId
+                                       errorMessage:&errorMessage]);
+        ASSERT_TRUE([captureDevice startCapture]);
 
-    base::RunLoop run_loop(base::RunLoop::Type::kNestableTasksAllowed);
-    size_t photo_error_count = 0;
-    EXPECT_CALL(frame_receiver, OnPhotoError)
-        .WillRepeatedly([&photo_error_count, &run_loop] {
-          ++photo_error_count;
-          if (photo_error_count == 3) {
-            run_loop.Quit();
-          }
-        });
-    [captureDevice takePhoto];
-    [captureDevice takePhoto];
-    [captureDevice takePhoto];
-    // There is no risk that takePhoto() has successfully finishes before
-    // stopCapture() because the takePhoto() calls involes a PostDelayedTask()
-    // that cannot run until RunLoop::Run() below.
-    [captureDevice stopCapture];
-    run_loop.Run();
-  }));
+        base::RunLoop run_loop(base::RunLoop::Type::kNestableTasksAllowed);
+        EXPECT_CALL(frame_receiver, OnPhotoError)
+            .WillOnce(Return())
+            .WillOnce(Return())
+            .WillOnce(base::test::RunClosure(run_loop.QuitClosure()));
+        [captureDevice takePhoto];
+        [captureDevice takePhoto];
+        [captureDevice takePhoto];
+        // There is no risk that takePhoto() has successfully finishes before
+        // stopCapture() because the takePhoto() calls involes a
+        // PostDelayedTask() that cannot run until RunLoop::Run() below.
+        [captureDevice stopCapture];
+        run_loop.Run();
+      },
+      this));
 }
 
-TEST(VideoCaptureDeviceAVFoundationMacTest,
-     StopStillImageOutputWhenNoLongerTakingPhotos) {
-  RunTestCase(base::BindOnce([] {
-    NSString* deviceId = GetFirstDeviceId();
-    if (!deviceId) {
-      DVLOG(1) << "No camera available. Exiting test.";
-      return;
-    }
+TEST_P(VideoCaptureDeviceAVFoundationMacTakePhotoTest,
+       StopPhotoOutputWhenNoLongerTakingPhotos) {
+  RunTestCase(base::BindOnce(
+      [](VideoCaptureDeviceAVFoundationMacTakePhotoTest* thiz) {
+        NSString* deviceId = GetFirstDeviceId();
+        if (!deviceId) {
+          DVLOG(1) << "No camera available. Exiting test.";
+          return;
+        }
 
-    testing::NiceMock<MockVideoCaptureDeviceAVFoundationFrameReceiver>
-        frame_receiver;
-    base::scoped_nsobject<VideoCaptureDeviceAVFoundation> captureDevice(
-        [[VideoCaptureDeviceAVFoundation alloc]
-            initWithFrameReceiver:&frame_receiver]);
+        testing::NiceMock<MockVideoCaptureDeviceAVFoundationFrameReceiver>
+            frame_receiver;
+        base::scoped_nsobject<VideoCaptureDeviceAVFoundation> captureDevice =
+            thiz->CreateCaptureDevice(&frame_receiver);
 
-    NSString* errorMessage = nil;
-    ASSERT_TRUE([captureDevice setCaptureDevice:deviceId
-                                   errorMessage:&errorMessage]);
-    ASSERT_TRUE([captureDevice startCapture]);
+        NSString* errorMessage = nil;
+        ASSERT_TRUE([captureDevice setCaptureDevice:deviceId
+                                       errorMessage:&errorMessage]);
+        ASSERT_TRUE([captureDevice startCapture]);
 
-    base::RunLoop run_loop(base::RunLoop::Type::kNestableTasksAllowed);
-    [captureDevice
-        setOnStillImageOutputStoppedForTesting:run_loop.QuitClosure()];
-    base::TimeTicks start_time = base::TimeTicks::Now();
-    [captureDevice takePhoto];
-    // The RunLoop automatically advances mocked time when there are delayed
-    // tasks pending. This allows the test to run fast and still assert how much
-    // mocked time has elapsed.
-    run_loop.Run();
-    auto time_elapsed = base::TimeTicks::Now() - start_time;
-    // Still image output is not stopped until 60 seconds of inactivity, so the
-    // mocked time must have advanced at least this much.
-    EXPECT_GE(time_elapsed.InSeconds(), 60);
-  }));
+        base::RunLoop run_loop(base::RunLoop::Type::kNestableTasksAllowed);
+        [captureDevice
+            setOnPhotoOutputStoppedForTesting:run_loop.QuitClosure()];
+        base::TimeTicks start_time = base::TimeTicks::Now();
+        [captureDevice takePhoto];
+        // The RunLoop automatically advances mocked time when there are delayed
+        // tasks pending. This allows the test to run fast and still assert how
+        // much mocked time has elapsed.
+        run_loop.Run();
+        auto time_elapsed = base::TimeTicks::Now() - start_time;
+        // Still image output is not stopped until 60 seconds of inactivity, so
+        // the mocked time must have advanced at least this much.
+        EXPECT_GE(time_elapsed.InSeconds(), 60);
+      },
+      this));
 }
 
-TEST(VideoCaptureDeviceAVFoundationMacTest,
-     TakePhotoAndShutDownWithoutWaiting) {
-  RunTestCase(base::BindOnce([] {
-    NSString* deviceId = GetFirstDeviceId();
-    if (!deviceId) {
-      DVLOG(1) << "No camera available. Exiting test.";
-      return;
-    }
+TEST_P(VideoCaptureDeviceAVFoundationMacTakePhotoTest,
+       TakePhotoAndShutDownWithoutWaiting) {
+  RunTestCase(base::BindOnce(
+      [](VideoCaptureDeviceAVFoundationMacTakePhotoTest* thiz) {
+        NSString* deviceId = GetFirstDeviceId();
+        if (!deviceId) {
+          DVLOG(1) << "No camera available. Exiting test.";
+          return;
+        }
 
-    testing::NiceMock<MockVideoCaptureDeviceAVFoundationFrameReceiver>
-        frame_receiver;
-    base::scoped_nsobject<VideoCaptureDeviceAVFoundation> captureDevice(
-        [[VideoCaptureDeviceAVFoundation alloc]
-            initWithFrameReceiver:&frame_receiver]);
+        testing::NiceMock<MockVideoCaptureDeviceAVFoundationFrameReceiver>
+            frame_receiver;
+        base::scoped_nsobject<VideoCaptureDeviceAVFoundation> captureDevice =
+            thiz->CreateCaptureDevice(&frame_receiver);
 
-    NSString* errorMessage = nil;
-    ASSERT_TRUE([captureDevice setCaptureDevice:deviceId
-                                   errorMessage:&errorMessage]);
-    ASSERT_TRUE([captureDevice startCapture]);
+        NSString* errorMessage = nil;
+        ASSERT_TRUE([captureDevice setCaptureDevice:deviceId
+                                       errorMessage:&errorMessage]);
+        ASSERT_TRUE([captureDevice startCapture]);
 
-    [captureDevice takePhoto];
-  }));
+        [captureDevice takePhoto];
+      },
+      this));
 }
 
+// When not forcing legacy API, AVCapturePhotoOutput is used if available
+// (macOS 10.15+). Otherwise AVCaptureStillImageOutput is used.
+INSTANTIATE_TEST_SUITE_P(VideoCaptureDeviceAVFoundationMacTakePhotoTest,
+                         VideoCaptureDeviceAVFoundationMacTakePhotoTest,
+                         // Force legacy API?
+                         testing::Values(false, true));
+
 TEST(VideoCaptureDeviceAVFoundationMacTest, ForwardsOddPixelBufferResolution) {
   // See crbug/1168112.
   RunTestCase(base::BindOnce([] {