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);
+// Larger int means better.
+enum class PixelFormatMatchType : int {
+  INCOMPATIBLE = 0,
+  SUPPORTED_THROUGH_CONVERSION = 1,

[mcasas, 2017/03/02 21:07:09]

IIUC SUPPORTED_THROUGH_CONVERSION has only
two uses, so who cares about it? What you want to define here
is a scale of unsupportedness, which is not what an enum
is for, and its use inside FindClosestSupportedFormat()
is obscure because of that.  Ideally, you should be able
to enumerate the formats in preference order, e.g.

// VideoPixelFormats in order from most to least preferred.
static kPreferredVideoPixelFormat kPreferredVideoPixelFormats[] = {
  // We like these formats less because they are Skia native.
  PIXEL_FORMAT_RGBA
  PIXEL_FORMAT_RGB32,
  // Next-best formats are those that need internal conversion.
  PIXEL_FORMAT_I420,
  PIXEL_FORMAT_MJPEG,
  //...
};

If all formats are present then
  static_assert(sizeof(kPreferredVideoPixelFormats) == PIXEL_FORMAT_MAX, "bla");
would be needed.

Perhaps this list should be a correspondence instead,
between requested pixel format to produced pixel format,
again in priority order. Might, I'm not sure.

[chfremer, 2017/03/02 23:03:04]

The root cause for why this admittedly ugly construct was needed is that clients
send their format request to the VCDevice but receive their frames from the
VCDeviceClient, which can perform conversion. 

Since the client also provides the VCDeviceClient, it should probably be itself
responsible to know which conversions it performs. Let me go clean that up in a
follow-up CL while the next CL is under review.

Will do.

+  EXACT = 2
+};
 
-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 &&
+      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) {}
+const media::VideoCaptureFormat& FindClosestSupportedFormat(
+    const VideoCaptureFormat& requested_format,
+    const VideoCaptureFormats& supported_formats) {
+  DCHECK(!supported_formats.empty());
+  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 (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;
+    }

[mcasas, 2017/03/02 21:07:09]

This code looks very familiar, is also in media_stream_video_source.cc, 
[1] it'd be cool to have it all in one single place, so that 
resolution-selecting policies are coherent across chrome. 

Can be a bug with a TODO().

[1] vicinity of
https://cs.chromium.org/chromium/src/content/renderer/media/media_stream_vide...

[chfremer, 2017/03/02 23:03:04]

I am going to look into it, and will track it as part of CL13b in the design
doc.

+  }
+  return supported_formats[best_index];
+}
 
-  uint32_t zoom;
-  VideoCaptureFormat format;
-};
-
-// 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;
     client_->OnStarted();
   }
-  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.";
+    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 VideoCaptureFormat& selected_format =
+      FindClosestSupportedFormat(params.requested_format, supported_formats_);
+
   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