Make FakeVideoCaptureDeviceFactory configurable to arbitrary fake device configurations

media/capture/video/fake_video_capture_device.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "media/capture/video/fake_video_capture_device.h"
 
 #include <stddef.h>
 #include <algorithm>
 #include <utility>
 
@@ skipping 11 matching lines @@
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkMatrix.h"
 #include "third_party/skia/include/core/SkPaint.h"
 #include "ui/gfx/codec/jpeg_codec.h"
 #include "ui/gfx/codec/png_codec.h"
 
 namespace media {
 
 namespace {
+
 // Sweep at 600 deg/sec.
 static const float kPacmanAngularVelocity = 600;
 // Beep every 500 ms.
 static const int kBeepInterval = 500;
 // Gradient travels from bottom to top in 5 seconds.
 static const float kGradientFrequency = 1.f / 5;
 
 static const double kMinZoom = 100.0;
 static const double kMaxZoom = 400.0;
 static const double kZoomStep = 1.0;
-static const double kInitialZoom = 100.0;
 
-static const gfx::Size kSupportedSizesOrderedByIncreasingWidth[] = {
-    gfx::Size(96, 96), gfx::Size(320, 240), gfx::Size(640, 480),
-    gfx::Size(1280, 720), gfx::Size(1920, 1080)};
-static const int kSupportedSizesCount =
-    arraysize(kSupportedSizesOrderedByIncreasingWidth);
+enum class PixelFormatMatchType {
+  EXACT,
+  SUPPORTED_THROUGH_CONVERSION,
+  INCOMPATIBLE
+};
 
-static gfx::Size SnapToSupportedSize(const gfx::Size& requested_size) {
-  for (const gfx::Size& supported_size :
-       kSupportedSizesOrderedByIncreasingWidth) {
-    if (requested_size.width() <= supported_size.width())
-      return supported_size;
+PixelFormatMatchType DetermineFormatMatchType(
+    media::VideoPixelFormat supported_format,
+    media::VideoPixelFormat requested_format) {
+  if (requested_format == media::PIXEL_FORMAT_I420) {

[emircan, 2017/03/01 18:58:58]

Merge to a single if statement.

[chfremer, 2017/03/01 21:55:48]

Done.

+    if (supported_format == media::PIXEL_FORMAT_MJPEG)
+      return PixelFormatMatchType::SUPPORTED_THROUGH_CONVERSION;
   }
-  return kSupportedSizesOrderedByIncreasingWidth[kSupportedSizesCount - 1];
+  return (requested_format == supported_format)
+             ? PixelFormatMatchType::EXACT
+             : PixelFormatMatchType::INCOMPATIBLE;
 }
 
-// Represents the current state of a FakeVideoCaptureDevice.
-// This is a separate struct because read-access to it is shared with several
-// collaborating classes.
-struct FakeDeviceState {
-  FakeDeviceState(float zoom, float frame_rate, VideoPixelFormat pixel_format)
-      : zoom(zoom),
-        format(gfx::Size(), frame_rate, pixel_format, PIXEL_STORAGE_CPU) {}
+bool CurrentFormatMatchIsWorseThanBest(PixelFormatMatchType current_match,
+                                       PixelFormatMatchType best_match) {
+  if (current_match == PixelFormatMatchType::INCOMPATIBLE) {

[emircan, 2017/03/01 18:58:58]

I don't think comparing like this is scalable. Can you just do |current_match >
best_match| since you actually ranked them in declaration?

[chfremer, 2017/03/01 21:55:48]

Done.

+    return best_match == PixelFormatMatchType::EXACT ||
+           best_match == PixelFormatMatchType::SUPPORTED_THROUGH_CONVERSION;
+  }
+  if (current_match == PixelFormatMatchType::SUPPORTED_THROUGH_CONVERSION)
+    return best_match == PixelFormatMatchType::EXACT;
+  return false;
+}
 
-  uint32_t zoom;
-  VideoCaptureFormat format;
-};
+int FindIndexOfClosestSupportedFormat(
+    const VideoCaptureFormat& requested_format,
+    const VideoCaptureFormats& supported_formats) {
+  int best_index = 0;
+  PixelFormatMatchType best_format_match = PixelFormatMatchType::INCOMPATIBLE;
+  int best_width_mismatch = std::numeric_limits<int>::max();
+  float best_frame_rate_mismatch = std::numeric_limits<float>::max();
+  for (int i = 0; i < static_cast<int>(supported_formats.size()); i++) {
+    const auto& supported_format = supported_formats[i];
+    PixelFormatMatchType current_format_match = DetermineFormatMatchType(
+        supported_format.pixel_format, requested_format.pixel_format);
+    if (CurrentFormatMatchIsWorseThanBest(current_format_match,
+                                          best_format_match)) {
+      continue;
+    }
+    if (supported_format.frame_size.width() <
+        requested_format.frame_size.width())
+      continue;
+    const int current_width_mismatch = supported_format.frame_size.width() -
+                                       requested_format.frame_size.width();
+    if (current_width_mismatch > best_width_mismatch)
+      continue;
+    const float current_frame_rate_mismatch =
+        std::abs(supported_format.frame_rate - requested_format.frame_rate);
+    if (current_width_mismatch < best_width_mismatch) {
+      best_width_mismatch = current_width_mismatch;
+      best_frame_rate_mismatch = current_frame_rate_mismatch;
+      best_index = i;
+      continue;
+    }
+    DCHECK_EQ(best_frame_rate_mismatch, current_frame_rate_mismatch);
+    if (current_frame_rate_mismatch < best_frame_rate_mismatch) {
+      best_frame_rate_mismatch = current_frame_rate_mismatch;
+      best_index = i;
+    }
+  }
+  return best_index;
+}
 
-// Paints a "pacman-like" animated circle including textual information such
-// as a frame count and timer.
-class PacmanFramePainter {
- public:
-  enum class Format { I420, SK_N32, Y16 };
-  PacmanFramePainter(Format pixel_format,
-                     const FakeDeviceState* fake_device_state);
-
-  void PaintFrame(base::TimeDelta elapsed_time, uint8_t* target_buffer);
-
- private:
-  void DrawGradientSquares(base::TimeDelta elapsed_time,
-                           uint8_t* target_buffer);
-
-  void DrawPacman(base::TimeDelta elapsed_time, uint8_t* target_buffer);
-
-  const Format pixel_format_;
-  const FakeDeviceState* fake_device_state_ = nullptr;
-};
+}  // anonymous namespace
 
 // Paints and delivers frames to a client, which is set via Initialize().
 class FrameDeliverer {
  public:
   FrameDeliverer(std::unique_ptr<PacmanFramePainter> frame_painter)
       : frame_painter_(std::move(frame_painter)) {}
   virtual ~FrameDeliverer() {}
   virtual void Initialize(VideoPixelFormat pixel_format,
                           std::unique_ptr<VideoCaptureDevice::Client> client,
                           const FakeDeviceState* device_state) {
     client_ = std::move(client);
     device_state_ = device_state;
   }
-  virtual void Uninitialize() {
-    client_.reset();
-    device_state_ = nullptr;
-  }
   virtual void PaintAndDeliverNextFrame(base::TimeDelta timestamp_to_paint) = 0;
 
  protected:
   base::TimeDelta CalculateTimeSinceFirstInvocation(base::TimeTicks now) {
     if (first_ref_time_.is_null())
       first_ref_time_ = now;
     return now - first_ref_time_;
   }
 
   PacmanFramePainter* frame_painter() { return frame_painter_.get(); }
@@ skipping 10 matching lines @@
 // Delivers frames using its own buffers via OnIncomingCapturedData().
 class OwnBufferFrameDeliverer : public FrameDeliverer {
  public:
   OwnBufferFrameDeliverer(std::unique_ptr<PacmanFramePainter> frame_painter);
   ~OwnBufferFrameDeliverer() override;
 
   // Implementation of FrameDeliverer
   void Initialize(VideoPixelFormat pixel_format,
                   std::unique_ptr<VideoCaptureDevice::Client> client,
                   const FakeDeviceState* device_state) override;
-  void Uninitialize() override;
   void PaintAndDeliverNextFrame(base::TimeDelta timestamp_to_paint) override;
 
  private:
   std::unique_ptr<uint8_t[]> buffer_;
 };
 
 // Delivers frames using buffers provided by the client via
 // OnIncomingCapturedBuffer().
 class ClientBufferFrameDeliverer : public FrameDeliverer {
  public:
   ClientBufferFrameDeliverer(std::unique_ptr<PacmanFramePainter> frame_painter);
   ~ClientBufferFrameDeliverer() override;
 
   // Implementation of FrameDeliverer
   void PaintAndDeliverNextFrame(base::TimeDelta timestamp_to_paint) override;
 };
 
 class JpegEncodingFrameDeliverer : public FrameDeliverer {
  public:
   JpegEncodingFrameDeliverer(std::unique_ptr<PacmanFramePainter> frame_painter);
   ~JpegEncodingFrameDeliverer() override;
 
   // Implementation of FrameDeliveryStrategy
-  void Uninitialize() override;
   void PaintAndDeliverNextFrame(base::TimeDelta timestamp_to_paint) override;
 
  private:
   std::vector<uint8_t> sk_n32_buffer_;
   std::vector<unsigned char> jpeg_buffer_;
 };
 
-// Implements the photo functionality of a VideoCaptureDevice
-class FakePhotoDevice {
- public:
-  FakePhotoDevice(std::unique_ptr<PacmanFramePainter> painter,
-                  const FakeDeviceState* fake_device_state);
-  ~FakePhotoDevice();
+FrameDelivererFactory::FrameDelivererFactory(
+    FakeVideoCaptureDevice::DeliveryMode delivery_mode,
+    const FakeDeviceState* device_state)
+    : delivery_mode_(delivery_mode), device_state_(device_state) {}
 
-  void GetPhotoCapabilities(
-      VideoCaptureDevice::GetPhotoCapabilitiesCallback callback);
-  void TakePhoto(VideoCaptureDevice::TakePhotoCallback callback,
-                 base::TimeDelta elapsed_time);
-
- private:
-  const std::unique_ptr<PacmanFramePainter> painter_;
-  const FakeDeviceState* const fake_device_state_;
-};
-
-// Implementation of VideoCaptureDevice that generates test frames. This is
-// useful for testing the video capture components without having to use real
-// devices. The implementation schedules delayed tasks to itself to generate and
-// deliver frames at the requested rate.
-class FakeVideoCaptureDevice : public VideoCaptureDevice {
- public:
-  FakeVideoCaptureDevice(
-      std::unique_ptr<FrameDeliverer> frame_delivery_strategy,
-      std::unique_ptr<FakePhotoDevice> photo_device,
-      std::unique_ptr<FakeDeviceState> device_state);
-  ~FakeVideoCaptureDevice() override;
-
-  // VideoCaptureDevice implementation.
-  void AllocateAndStart(const VideoCaptureParams& params,
-                        std::unique_ptr<Client> client) override;
-  void StopAndDeAllocate() override;
-  void GetPhotoCapabilities(GetPhotoCapabilitiesCallback callback) override;
-  void SetPhotoOptions(mojom::PhotoSettingsPtr settings,
-                       SetPhotoOptionsCallback callback) override;
-  void TakePhoto(TakePhotoCallback callback) override;
-
- private:
-  void BeepAndScheduleNextCapture(base::TimeTicks expected_execution_time);
-  void OnNextFrameDue(base::TimeTicks expected_execution_time, int session_id);
-
-  const std::unique_ptr<FrameDeliverer> frame_deliverer_;
-  const std::unique_ptr<FakePhotoDevice> photo_device_;
-  const std::unique_ptr<FakeDeviceState> device_state_;
-  int current_session_id_ = 0;
-
-  // Time when the next beep occurs.
-  base::TimeDelta beep_time_;
-  // Time since the fake video started rendering frames.
-  base::TimeDelta elapsed_time_;
-
-  base::ThreadChecker thread_checker_;
-
-  // FakeVideoCaptureDevice post tasks to itself for frame construction and
-  // needs to deal with asynchronous StopAndDeallocate().
-  base::WeakPtrFactory<FakeVideoCaptureDevice> weak_factory_;
-
-  DISALLOW_COPY_AND_ASSIGN(FakeVideoCaptureDevice);
-};
-
-}  // anonymous namespace
-
-// static
-void FakeVideoCaptureDeviceMaker::GetSupportedSizes(
-    std::vector<gfx::Size>* supported_sizes) {
-  for (int i = 0; i < kSupportedSizesCount; i++)
-    supported_sizes->push_back(kSupportedSizesOrderedByIncreasingWidth[i]);
-}
-
-// static
-std::unique_ptr<VideoCaptureDevice> FakeVideoCaptureDeviceMaker::MakeInstance(
-    PixelFormat pixel_format,
-    DeliveryMode delivery_mode,
-    float frame_rate) {
-  auto device_state = base::MakeUnique<FakeDeviceState>(
-      kInitialZoom, frame_rate,
-      static_cast<media::VideoPixelFormat>(pixel_format));
+std::unique_ptr<FrameDeliverer> FrameDelivererFactory::CreateFrameDeliverer(
+    const VideoCaptureFormat& format) {
   PacmanFramePainter::Format painter_format;
-  switch (pixel_format) {
-    case PixelFormat::I420:
+  switch (format.pixel_format) {
+    case PIXEL_FORMAT_I420:
       painter_format = PacmanFramePainter::Format::I420;
       break;
-    case PixelFormat::Y16:
+    case PIXEL_FORMAT_Y16:
       painter_format = PacmanFramePainter::Format::Y16;
       break;
-    case PixelFormat::MJPEG:
+    case PIXEL_FORMAT_MJPEG:
       painter_format = PacmanFramePainter::Format::SK_N32;
       break;
+    default:
+      NOTREACHED();
+      painter_format = PacmanFramePainter::Format::I420;
   }
-  auto video_frame_painter =
-      base::MakeUnique<PacmanFramePainter>(painter_format, device_state.get());
+  auto frame_painter =
+      base::MakeUnique<PacmanFramePainter>(painter_format, device_state_);
 
-  std::unique_ptr<FrameDeliverer> frame_delivery_strategy;
-  switch (delivery_mode) {
-    case DeliveryMode::USE_DEVICE_INTERNAL_BUFFERS:
-      if (pixel_format == PixelFormat::MJPEG) {
-        frame_delivery_strategy = base::MakeUnique<JpegEncodingFrameDeliverer>(
-            std::move(video_frame_painter));
-      } else {
-        frame_delivery_strategy = base::MakeUnique<OwnBufferFrameDeliverer>(
-            std::move(video_frame_painter));
-      }
-      break;
-    case DeliveryMode::USE_CLIENT_PROVIDED_BUFFERS:
-      if (pixel_format == PixelFormat::MJPEG) {
-        DLOG(ERROR) << "PixelFormat::MJPEG cannot be used in combination with "
-                    << "USE_CLIENT_PROVIDED_BUFFERS.";
-        return nullptr;
-      }
-      frame_delivery_strategy = base::MakeUnique<ClientBufferFrameDeliverer>(
-          std::move(video_frame_painter));
-      break;
+  FakeVideoCaptureDevice::DeliveryMode delivery_mode = delivery_mode_;
+  if (format.pixel_format == PIXEL_FORMAT_MJPEG &&
+      delivery_mode_ ==
+          FakeVideoCaptureDevice::DeliveryMode::USE_CLIENT_PROVIDED_BUFFERS) {
+    DLOG(WARNING) << "PIXEL_FORMAT_MJPEG cannot be used in combination with "
+                  << "USE_CLIENT_PROVIDED_BUFFERS. Switching to "
+                     "USE_DEVICE_INTERNAL_BUFFERS.";

[emircan, 2017/03/01 18:58:58]

We should still return an error here to propagate proper use.

[chfremer, 2017/03/01 21:55:48]

I tried out your suggestions but then ended up reverting.
The reason is that properly supporting an error case for this requires adding
quite a bit of complexity. 

In addition to returning nullptr here, we would have to make sure the
FakeVideoCaptureDeviceFactory::GetSupportedFormats() strips out all MJPEG
formats when using USE_CLIENT_PROVIDED_BUFFERS. And then, we would probably want
to strip those cases out already when they are set in one of the configuration
calls, but it would be bad to do that silently. So we would have to add an error
case to the configuration API. And then we would need unit test cases for all
this.

Considering this, I feel the silent switching to USE_DEVICE_INTERNAL_BUFFERS is
probably the better choice.

[emircan, 2017/03/02 20:28:18]

Sounds good.

+    delivery_mode =
+        FakeVideoCaptureDevice::DeliveryMode::USE_DEVICE_INTERNAL_BUFFERS;
   }
 
-  auto photo_frame_painter = base::MakeUnique<PacmanFramePainter>(
-      PacmanFramePainter::Format::SK_N32, device_state.get());
-  auto photo_device = base::MakeUnique<FakePhotoDevice>(
-      std::move(photo_frame_painter), device_state.get());
-
-  return base::MakeUnique<FakeVideoCaptureDevice>(
-      std::move(frame_delivery_strategy), std::move(photo_device),
-      std::move(device_state));
+  switch (delivery_mode) {
+    case FakeVideoCaptureDevice::DeliveryMode::USE_DEVICE_INTERNAL_BUFFERS:
+      if (format.pixel_format == PIXEL_FORMAT_MJPEG) {
+        return base::MakeUnique<JpegEncodingFrameDeliverer>(
+            std::move(frame_painter));
+      } else {
+        return base::MakeUnique<OwnBufferFrameDeliverer>(
+            std::move(frame_painter));
+      }
+    case FakeVideoCaptureDevice::DeliveryMode::USE_CLIENT_PROVIDED_BUFFERS:
+      return base::MakeUnique<ClientBufferFrameDeliverer>(
+          std::move(frame_painter));
+  }
+  NOTREACHED();
+  return nullptr;
 }
 
 PacmanFramePainter::PacmanFramePainter(Format pixel_format,
                                        const FakeDeviceState* fake_device_state)
     : pixel_format_(pixel_format), fake_device_state_(fake_device_state) {}
 
 void PacmanFramePainter::PaintFrame(base::TimeDelta elapsed_time,
                                     uint8_t* target_buffer) {
   DrawPacman(elapsed_time, target_buffer);
   DrawGradientSquares(elapsed_time, target_buffer);
@@ skipping 118 matching lines @@
   canvas.drawText(time_string.data(), time_string.length(), 30, 20, paint);
 
   if (pixel_format_ == Format::Y16) {
     // Use 8 bit bitmap rendered to first half of the buffer as high byte values
     // for the whole buffer. Low byte values are not important.
     for (int i = (width * height) - 1; i >= 0; --i)
       target_buffer[i * 2 + 1] = target_buffer[i];
   }
 }
 
-FakePhotoDevice::FakePhotoDevice(std::unique_ptr<PacmanFramePainter> painter,
-                                 const FakeDeviceState* fake_device_state)
-    : painter_(std::move(painter)), fake_device_state_(fake_device_state) {}
+FakePhotoDevice::FakePhotoDevice(
+    std::unique_ptr<PacmanFramePainter> sk_n32_painter,
+    const FakeDeviceState* fake_device_state)
+    : sk_n32_painter_(std::move(sk_n32_painter)),
+      fake_device_state_(fake_device_state) {}
 
 FakePhotoDevice::~FakePhotoDevice() = default;
 
 void FakePhotoDevice::TakePhoto(VideoCaptureDevice::TakePhotoCallback callback,
                                 base::TimeDelta elapsed_time) {
   // Create a PNG-encoded frame and send it back to |callback|.
   auto required_sk_n32_buffer_size = VideoFrame::AllocationSize(
       PIXEL_FORMAT_ARGB, fake_device_state_->format.frame_size);
   std::unique_ptr<uint8_t[]> buffer(new uint8_t[required_sk_n32_buffer_size]);
   memset(buffer.get(), 0, required_sk_n32_buffer_size);
-  painter_->PaintFrame(elapsed_time, buffer.get());
+  sk_n32_painter_->PaintFrame(elapsed_time, buffer.get());
   mojom::BlobPtr blob = mojom::Blob::New();
   const gfx::PNGCodec::ColorFormat encoding_source_format =
       (kN32_SkColorType == kRGBA_8888_SkColorType) ? gfx::PNGCodec::FORMAT_RGBA
                                                    : gfx::PNGCodec::FORMAT_BGRA;
   const bool result = gfx::PNGCodec::Encode(
       buffer.get(), encoding_source_format,
       fake_device_state_->format.frame_size,
       VideoFrame::RowBytes(0 /* plane */, PIXEL_FORMAT_ARGB,
                            fake_device_state_->format.frame_size.width()),
       true /* discard_transparency */, std::vector<gfx::PNGCodec::Comment>(),
       &blob->data);
   DCHECK(result);
 
   blob->mime_type = "image/png";
   callback.Run(std::move(blob));
 }
 
 FakeVideoCaptureDevice::FakeVideoCaptureDevice(
-    std::unique_ptr<FrameDeliverer> frame_delivery_strategy,
+    const VideoCaptureFormats& supported_formats,
+    std::unique_ptr<FrameDelivererFactory> frame_deliverer_factory,
     std::unique_ptr<FakePhotoDevice> photo_device,
     std::unique_ptr<FakeDeviceState> device_state)
-    : frame_deliverer_(std::move(frame_delivery_strategy)),
+    : supported_formats_(supported_formats),
+      frame_deliverer_factory_(std::move(frame_deliverer_factory)),
       photo_device_(std::move(photo_device)),
       device_state_(std::move(device_state)),
       weak_factory_(this) {}
 
 FakeVideoCaptureDevice::~FakeVideoCaptureDevice() {
   DCHECK(thread_checker_.CalledOnValidThread());
 }
 
 void FakeVideoCaptureDevice::AllocateAndStart(
     const VideoCaptureParams& params,
     std::unique_ptr<VideoCaptureDevice::Client> client) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
+  const int closest_supported_format_index = FindIndexOfClosestSupportedFormat(
+      params.requested_format, supported_formats_);
+  const VideoCaptureFormat& selected_format =
+      supported_formats_[closest_supported_format_index];

[emircan, 2017/03/01 18:58:58]

Why don't we make the function FindClosestSupportedFormat() since we do not have
any other use for the index?

[chfremer, 2017/03/01 21:55:48]

Done.

+
   beep_time_ = base::TimeDelta();
   elapsed_time_ = base::TimeDelta();
-  device_state_->format.frame_size =
-      SnapToSupportedSize(params.requested_format.frame_size);
+  frame_deliverer_ =
+      frame_deliverer_factory_->CreateFrameDeliverer(selected_format);
+  device_state_->format.frame_size = selected_format.frame_size;
   frame_deliverer_->Initialize(device_state_->format.pixel_format,
                                std::move(client), device_state_.get());
   current_session_id_++;
   BeepAndScheduleNextCapture(base::TimeTicks::Now());
 }
 
 void FakeVideoCaptureDevice::StopAndDeAllocate() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // Invalidate WeakPtr to stop the perpetual scheduling of tasks.
   weak_factory_.InvalidateWeakPtrs();
-  frame_deliverer_->Uninitialize();
+  frame_deliverer_.reset();
 }
 
 void FakeVideoCaptureDevice::GetPhotoCapabilities(
     GetPhotoCapabilitiesCallback callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   photo_device_->GetPhotoCapabilities(std::move(callback));
 }
 
 void FakePhotoDevice::GetPhotoCapabilities(
     VideoCaptureDevice::GetPhotoCapabilitiesCallback callback) {
@@ skipping 62 matching lines @@
 
 void OwnBufferFrameDeliverer::Initialize(
     VideoPixelFormat pixel_format,
     std::unique_ptr<VideoCaptureDevice::Client> client,
     const FakeDeviceState* device_state) {
   FrameDeliverer::Initialize(pixel_format, std::move(client), device_state);
   buffer_.reset(new uint8_t[VideoFrame::AllocationSize(
       pixel_format, device_state->format.frame_size)]);
 }
 
-void OwnBufferFrameDeliverer::Uninitialize() {
-  FrameDeliverer::Uninitialize();
-  buffer_.reset();
-}
-
 void OwnBufferFrameDeliverer::PaintAndDeliverNextFrame(
     base::TimeDelta timestamp_to_paint) {
   if (!client())
     return;
   const size_t frame_size = device_state()->format.ImageAllocationSize();
   memset(buffer_.get(), 0, frame_size);
   frame_painter()->PaintFrame(timestamp_to_paint, buffer_.get());
   base::TimeTicks now = base::TimeTicks::Now();
   client()->OnIncomingCapturedData(buffer_.get(), frame_size,
                                    device_state()->format, 0 /* rotation */,
@@ skipping 32 matching lines @@
                                      device_state()->format, now,
                                      CalculateTimeSinceFirstInvocation(now));
 }
 
 JpegEncodingFrameDeliverer::JpegEncodingFrameDeliverer(
     std::unique_ptr<PacmanFramePainter> frame_painter)
     : FrameDeliverer(std::move(frame_painter)) {}
 
 JpegEncodingFrameDeliverer::~JpegEncodingFrameDeliverer() = default;
 
-void JpegEncodingFrameDeliverer::Uninitialize() {
-  FrameDeliverer::Uninitialize();
-  sk_n32_buffer_.clear();
-  jpeg_buffer_.clear();
-}
-
 void JpegEncodingFrameDeliverer::PaintAndDeliverNextFrame(
     base::TimeDelta timestamp_to_paint) {
   if (!client())
     return;
 
   auto required_sk_n32_buffer_size = VideoFrame::AllocationSize(
       PIXEL_FORMAT_ARGB, device_state()->format.frame_size);
   sk_n32_buffer_.resize(required_sk_n32_buffer_size);
   memset(&sk_n32_buffer_[0], 0, required_sk_n32_buffer_size);
 
@@ skipping 59 matching lines @@
     int session_id) {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (session_id != current_session_id_)
     return;
 
   frame_deliverer_->PaintAndDeliverNextFrame(elapsed_time_);
   BeepAndScheduleNextCapture(expected_execution_time);
 }
 
 }  // namespace media