Add MJPEG support to FakeVideoCaptureDevice

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>
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/stringprintf.h"
 #include "base/threading/thread_checker.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "media/audio/fake_audio_input_stream.h"
 #include "media/base/video_frame.h"
 #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);
 
-static const VideoPixelFormat kSupportedPixelFormats[] = {
-    PIXEL_FORMAT_I420, PIXEL_FORMAT_Y16, PIXEL_FORMAT_ARGB};
-
 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;
   }
   return kSupportedSizesOrderedByIncreasingWidth[kSupportedSizesCount - 1];
 }
 
 // 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) {}
 
   uint32_t zoom;
   VideoCaptureFormat format;
 };
 
 // Paints a "pacman-like" animated circle including textual information such
 // as a frame count and timer.
 class PacmanFramePainter {
  public:
-  // Currently, only the following values are supported for |pixel_format|:
-  //   PIXEL_FORMAT_I420
-  //   PIXEL_FORMAT_Y16
-  //   PIXEL_FORMAT_ARGB
-  PacmanFramePainter(VideoPixelFormat pixel_format,
+  enum class Format { I420, RGB, 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 VideoPixelFormat pixel_format_;
+  const Format pixel_format_;
   const FakeDeviceState* fake_device_state_ = nullptr;
 };
 
 // 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) = 0;
-  virtual void Uninitialize() = 0;
+  void Initialize(VideoPixelFormat pixel_format,
+                  std::unique_ptr<VideoCaptureDevice::Client> client,
+                  const FakeDeviceState* device_state) {
+    client_ = std::move(client);
+    device_state_ = device_state;
+    InitializeDerived(pixel_format);
+  }
+  void Uninitialize() {
+    UninitializeDerived();
+    client_.reset();
+    device_state_ = nullptr;
+  }
   virtual void PaintAndDeliverNextFrame(base::TimeDelta timestamp_to_paint) = 0;
 
  protected:
+  virtual void InitializeDerived(VideoPixelFormat pixel_format) {}
+  virtual void UninitializeDerived() {}
+
   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(); }
+  const FakeDeviceState* device_state() { return device_state_; }
+  VideoCaptureDevice::Client* client() { return client_.get(); }
+  bool has_client() { return client_ != nullptr; }

[mcasas, 2017/02/22 20:26:33]

bool HasClient() const { return !client_; }

but IMHO is not needed, just use !client()
in the call sites

[chfremer, 2017/02/23 01:14:28]

Done.

+
+ private:
   const std::unique_ptr<PacmanFramePainter> frame_painter_;
   const FakeDeviceState* device_state_ = nullptr;
   std::unique_ptr<VideoCaptureDevice::Client> client_;
-
- private:
   base::TimeTicks first_ref_time_;
 };
 
 // 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 InitializeDerived(VideoPixelFormat pixel_format) override;
+  void UninitializeDerived() override;

[mcasas, 2017/02/22 20:26:32]

There's no need for these ...Derived() guys, instead:

class FrameDeliverer {
 pubic:
  virtual void Initialize(...) { ...}
};

class OwnBufferFrameDeliverer {
 public:
  void Initialize() override {
    FrameDeliverer::Initialize(...);
    // specific stuff here
  }
};

I like this call-super much better, but MFowler doesn't [1].
So if you still prefer the override-ways, then please 
substitute "Derived" for something meaningful (like, e.g.
"Buffers"?).

[1] https://www.martinfowler.com/bliki/CallSuper.html

[chfremer, 2017/02/23 01:14:28]

I am intentionally avoiding requiring the call to super.

I agree that the ...Derived is a desparate solution for a name. The reason I
ended up choosing this name is, because I wanted to avoid the base class knowing
or assuming anything about the implementation of the subclasses. Naming the
template method InitializeBuffers() would imply 
that the base class knows that all subclasses involve 
some buffers they want to initialize when this is called.

I guess I got stuck half way between using inheritance and composition. Since
you seem to prefer using inheritance here, I'll go with your suggestion.

Done.

   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 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;
 };
 
+class JpegEncodingFrameDeliverer : public FrameDeliverer {
+ public:
+  JpegEncodingFrameDeliverer(std::unique_ptr<PacmanFramePainter> frame_painter);
+  ~JpegEncodingFrameDeliverer() override;
+
+  // Implementation of FrameDeliveryStrategy
+  void UninitializeDerived() override;
+  void PaintAndDeliverNextFrame(base::TimeDelta timestamp_to_paint) override;
+
+ private:
+  std::vector<uint8_t> rgb_buffer_;
+  std::vector<unsigned char> jpeg_buffer_;
+};
+
 // Implements the photo functionality of a VideoCaptureDevice
 class FakePhotoDevice {
  public:
-  FakePhotoDevice(std::unique_ptr<PacmanFramePainter> argb_painter,
+  FakePhotoDevice(std::unique_ptr<PacmanFramePainter> rgb_painter,
                   const FakeDeviceState* fake_device_state);
   ~FakePhotoDevice();
 
   void GetPhotoCapabilities(
       VideoCaptureDevice::GetPhotoCapabilitiesCallback callback);
   void TakePhoto(VideoCaptureDevice::TakePhotoCallback callback,
                  base::TimeDelta elapsed_time);
 
  private:
-  const std::unique_ptr<PacmanFramePainter> argb_painter_;
+  const std::unique_ptr<PacmanFramePainter> rgb_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(
@@ skipping 37 matching lines @@
 }  // 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
+media::VideoPixelFormat
+FakeVideoCaptureDeviceMaker::TranslateToMediaVideoPixelFormat(
+    FakeVideoCaptureDeviceMaker::PixelFormat format) {
+  switch (format) {
+    case FakeVideoCaptureDeviceMaker::PixelFormat::I420:
+      return media::PIXEL_FORMAT_I420;
+    case FakeVideoCaptureDeviceMaker::PixelFormat::Y16:
+      return media::PIXEL_FORMAT_Y16;
+    case FakeVideoCaptureDeviceMaker::PixelFormat::MJPEG:
+      return media::PIXEL_FORMAT_MJPEG;
+  }
+  // This is just to satisfy compilers that otherwise complain about control
+  // reaching end of non-void method.

[mcasas, 2017/02/22 20:26:33]

This is a widespread pattern in Chromium, no
need to add a comment for this.

[chfremer, 2017/02/23 01:14:28]

Done.

+  NOTREACHED();
+  return media::PIXEL_FORMAT_UNKNOWN;
+}
+
+// static
 std::unique_ptr<VideoCaptureDevice> FakeVideoCaptureDeviceMaker::MakeInstance(
-    VideoPixelFormat pixel_format,
+    PixelFormat pixel_format,
     DeliveryMode delivery_mode,
     float frame_rate) {
-  bool pixel_format_supported = false;
-  for (const auto& supported_pixel_format : kSupportedPixelFormats) {
-    if (pixel_format == supported_pixel_format) {
-      pixel_format_supported = true;
+  auto device_state = base::MakeUnique<FakeDeviceState>(
+      kInitialZoom, frame_rate, TranslateToMediaVideoPixelFormat(pixel_format));
+  PacmanFramePainter::Format painter_format;
+  switch (pixel_format) {
+    case PixelFormat::I420:
+      painter_format = PacmanFramePainter::Format::I420;
       break;
-    }
+    case PixelFormat::Y16:
+      painter_format = PacmanFramePainter::Format::Y16;
+      break;
+    case PixelFormat::MJPEG:
+      painter_format = PacmanFramePainter::Format::RGB;
+      break;
   }
-  if (!pixel_format_supported) {
-    DLOG(ERROR) << "Requested an unsupported pixel format "
-                << VideoPixelFormatToString(pixel_format);
-    return nullptr;
-  }
+  auto video_frame_painter =
+      base::MakeUnique<PacmanFramePainter>(painter_format, device_state.get());
 
-  auto device_state =
-      base::MakeUnique<FakeDeviceState>(kInitialZoom, frame_rate, pixel_format);
-  auto video_frame_painter =
-      base::MakeUnique<PacmanFramePainter>(pixel_format, device_state.get());
   std::unique_ptr<FrameDeliverer> frame_delivery_strategy;
   switch (delivery_mode) {
     case DeliveryMode::USE_DEVICE_INTERNAL_BUFFERS:
-      frame_delivery_strategy = base::MakeUnique<OwnBufferFrameDeliverer>(
-          std::move(video_frame_painter));
+      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;
   }
 
   auto photo_frame_painter = base::MakeUnique<PacmanFramePainter>(
-      PIXEL_FORMAT_ARGB, device_state.get());
+      PacmanFramePainter::Format::RGB, 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));
 }
 
-PacmanFramePainter::PacmanFramePainter(VideoPixelFormat pixel_format,
+PacmanFramePainter::PacmanFramePainter(Format pixel_format,
                                        const FakeDeviceState* fake_device_state)
-    : pixel_format_(pixel_format), fake_device_state_(fake_device_state) {
-  DCHECK(pixel_format == PIXEL_FORMAT_I420 ||
-         pixel_format == PIXEL_FORMAT_Y16 || pixel_format == PIXEL_FORMAT_ARGB);
-}
+    : 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);
 }
 
 // Starting from top left, -45 deg gradient.  Value at point (row, column) is
 // calculated as (top_left_value + (row + column) * step) % MAX_VALUE, where
 // step is MAX_VALUE / (width + height).  MAX_VALUE is 255 (for 8 bit per
@@ skipping 13 matching lines @@
   const float start =
       fmod(65536 * elapsed_time.InSecondsF() * kGradientFrequency, 65536);
   const float color_step = 65535 / static_cast<float>(width + height);
   for (const auto& corner : squares) {
     for (int y = corner.y(); y < corner.y() + side; ++y) {
       for (int x = corner.x(); x < corner.x() + side; ++x) {
         const unsigned int value =
             static_cast<unsigned int>(start + (x + y) * color_step) & 0xFFFF;
         size_t offset = (y * width) + x;
         switch (pixel_format_) {
-          case PIXEL_FORMAT_Y16:
+          case Format::Y16:
             target_buffer[offset * sizeof(uint16_t)] = value & 0xFF;
             target_buffer[offset * sizeof(uint16_t) + 1] = value >> 8;
             break;
-          case PIXEL_FORMAT_ARGB:
-            target_buffer[offset * sizeof(uint32_t) + 1] = value >> 8;
-            target_buffer[offset * sizeof(uint32_t) + 2] = value >> 8;
-            target_buffer[offset * sizeof(uint32_t) + 3] = value >> 8;
+          case Format::RGB:

[mcasas, 2017/02/22 20:26:33]

I'd advice against touching code in CLs where you
mostly add new stuff.  Also, in the vast majority of
cases, RGB32s are more performant than RGB24 
format, which is hard to work with due to the strange
alignment (in many cases, such as Windows, RGB24
is implemented as RGB32 ignoring one component)
and the multiplications by 3 (as opposed to 4 where
compilers will insert fast SIMD-shifts).
So: please leave the ARGB parts in place, here and
elsewhere.

[chfremer, 2017/02/23 01:14:28]

Agreed that mixing new stuff with changing old stuff is not a great idea. I was
hoping to offer a resolution to your comment on the earlier patchset pointing
out the mismatch between the format expected by the encoder for JPG (RGBA) and
the format delivered by the painter (RGBA or BGRA depending on the platform). 

Since SkBitmap does not support cross-platform painting in RGBA I thought this
would be viable solution. But it seems like the encoders support both RGBA and
BGRA, so for the latest patch set I reverted back to painting in Sk_N32 and then
telling the encoders which source format to use.

Done.

+            target_buffer[offset * 3 + 0] = value >> 8;
+            target_buffer[offset * 3 + 1] = value >> 8;
+            target_buffer[offset * 3 + 2] = value >> 8;
             break;
-          default:
+          case Format::I420:
             target_buffer[offset] = value >> 8;
             break;
         }
       }
     }
   }
 }
 
 void PacmanFramePainter::DrawPacman(base::TimeDelta elapsed_time,
                                     uint8_t* target_buffer) {
   const int width = fake_device_state_->format.frame_size.width();
   const int height = fake_device_state_->format.frame_size.height();
 
-  // |kN32_SkColorType| stands for the appropriate RGBA/BGRA format.
-  const SkColorType colorspace = (pixel_format_ == PIXEL_FORMAT_ARGB)
-                                     ? kN32_SkColorType
-                                     : kAlpha_8_SkColorType;
-  // Skia doesn't support 16 bit alpha rendering, so we 8 bit alpha and then use
-  // this as high byte values in 16 bit pixels.
+  // Skia doesn't support painting in I420, RGB, or Y16.
+  // We paint an 8bpp monochrome image to the beginning of |target_buffer|.
+  // For I420, this section of |target_buffer| corresponds to the Y-plane of the
+  // YUV image. We do not touch the U or V planes of |target_buffer|.
+  // Assuming they have been initialized to 0, which corresponds to a green
+  // color tone, the result will be an green-ish monochrome frame.
+  // For RGB, we later move the bytes to fill the green channel of the RGB
+  // pixels. For Y16, we later move the 8bit pixel values to a position
+  // corresponding to the high byte values of 16bit pixel values (assuming the
+  // order is little-endian).
+  const SkColorType colorspace = kAlpha_8_SkColorType;
   const SkImageInfo info =
       SkImageInfo::Make(width, height, colorspace, kOpaque_SkAlphaType);
   SkBitmap bitmap;
   bitmap.setInfo(info);
   bitmap.setPixels(target_buffer);
   SkPaint paint;
   paint.setStyle(SkPaint::kFill_Style);
   SkCanvas canvas(bitmap);
 
   const SkScalar unscaled_zoom = fake_device_state_->zoom / 100.f;
   SkMatrix matrix;
   matrix.setScale(unscaled_zoom, unscaled_zoom, width / 2, height / 2);
   canvas.setMatrix(matrix);
 
-  // Equalize Alpha_8 that has light green background while RGBA has white.
-  if (pixel_format_ == PIXEL_FORMAT_ARGB) {
-    const SkRect full_frame = SkRect::MakeWH(width, height);
-    paint.setARGB(255, 0, 127, 0);
-    canvas.drawRect(full_frame, paint);
-  }
-  paint.setColor(SK_ColorGREEN);
-
   // Draw a sweeping circle to show an animation.
   const float end_angle =
       fmod(kPacmanAngularVelocity * elapsed_time.InSecondsF(), 361);
   const int radius = std::min(width, height) / 4;
   const SkRect rect = SkRect::MakeXYWH(width / 2 - radius, height / 2 - radius,
                                        2 * radius, 2 * radius);
   canvas.drawArc(rect, 0, end_angle, true, paint);
 
   // Draw current time.
   const int milliseconds = elapsed_time.InMilliseconds() % 1000;
   const int seconds = elapsed_time.InSeconds() % 60;
   const int minutes = elapsed_time.InMinutes() % 60;
   const int hours = elapsed_time.InHours();
   const int frame_count = elapsed_time.InMilliseconds() *
                           fake_device_state_->format.frame_rate / 1000;
 
   const std::string time_string =
       base::StringPrintf("%d:%02d:%02d:%03d %d", hours, minutes, seconds,
                          milliseconds, frame_count);
   canvas.scale(3, 3);
   canvas.drawText(time_string.data(), time_string.length(), 30, 20, paint);
 
-  if (pixel_format_ == PIXEL_FORMAT_Y16) {
+  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];
+  } else if (pixel_format_ == Format::RGB) {
+    // Move 8 bit pixel values to the green channel of 24bit RGB pixel values.
+    for (int i = (width * height) - 1; i >= 0; --i) {
+      target_buffer[i * 3 + 1] = target_buffer[i];
+      target_buffer[i] = 0u;
+    }

[mcasas, 2017/02/22 20:26:33]

I'm not sure this pixel swizzling is clearer than what was before, 
where we could at least see the 
  paint.setARGB(255, 0, 127, 0);
Can we do all this movements in any other way?  Maybe
we can use some nice libyuv function.

[chfremer, 2017/02/23 01:14:28]

Definitely not clearer. Removed.

   }
 }
 
 FakePhotoDevice::FakePhotoDevice(
-    std::unique_ptr<PacmanFramePainter> argb_painter,
+    std::unique_ptr<PacmanFramePainter> rgb_painter,
     const FakeDeviceState* fake_device_state)
-    : argb_painter_(std::move(argb_painter)),
+    : rgb_painter_(std::move(rgb_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|.
-  std::unique_ptr<uint8_t[]> buffer(new uint8_t[VideoFrame::AllocationSize(
-      PIXEL_FORMAT_ARGB, fake_device_state_->format.frame_size)]);
-  argb_painter_->PaintFrame(elapsed_time, buffer.get());
+  auto required_rgb_buffer_size = VideoFrame::AllocationSize(
+      PIXEL_FORMAT_RGB24, fake_device_state_->format.frame_size);
+  std::unique_ptr<uint8_t[]> buffer(new uint8_t[required_rgb_buffer_size]);
+  memset(buffer.get(), 0, required_rgb_buffer_size);
+  rgb_painter_->PaintFrame(elapsed_time, buffer.get());
   mojom::BlobPtr blob = mojom::Blob::New();
-  const bool result =
-      gfx::PNGCodec::Encode(buffer.get(), gfx::PNGCodec::FORMAT_RGBA,
-                            fake_device_state_->format.frame_size,
-                            fake_device_state_->format.frame_size.width() * 4,
-                            true /* discard_transparency */,
-                            std::vector<gfx::PNGCodec::Comment>(), &blob->data);
+  const bool result = gfx::PNGCodec::Encode(
+      buffer.get(), gfx::PNGCodec::FORMAT_RGB,
+      fake_device_state_->format.frame_size,
+      VideoFrame::RowBytes(0 /* plane */, PIXEL_FORMAT_RGB24,
+                           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,
     std::unique_ptr<FakePhotoDevice> photo_device,
     std::unique_ptr<FakeDeviceState> device_state)
@@ skipping 87 matching lines @@
 }
 
 void FakeVideoCaptureDevice::TakePhoto(TakePhotoCallback callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::Bind(&FakePhotoDevice::TakePhoto,
                             base::Unretained(photo_device_.get()),
                             base::Passed(&callback), elapsed_time_));
 }
 
+JpegEncodingFrameDeliverer::JpegEncodingFrameDeliverer(

[mcasas, 2017/02/22 20:26:33]

JpegEncodingFrameDeliverer is declared after 
OwnBufferFrameDeliverer and ClientBufferFrameDeliverer,
but here the definition goes before.  Make it consistent.

[chfremer, 2017/02/23 01:14:28]

Done.

+    std::unique_ptr<PacmanFramePainter> frame_painter)
+    : FrameDeliverer(std::move(frame_painter)) {}
+
+JpegEncodingFrameDeliverer::~JpegEncodingFrameDeliverer() = default;
+
+void JpegEncodingFrameDeliverer::UninitializeDerived() {
+  rgb_buffer_.clear();
+  jpeg_buffer_.clear();
+}
+
+void JpegEncodingFrameDeliverer::PaintAndDeliverNextFrame(
+    base::TimeDelta timestamp_to_paint) {
+  if (!has_client())
+    return;
+
+  auto required_rgb_buffer_size = VideoFrame::AllocationSize(
+      PIXEL_FORMAT_RGB24, device_state()->format.frame_size);
+  rgb_buffer_.resize(required_rgb_buffer_size);
+  memset(&rgb_buffer_[0], 0, required_rgb_buffer_size);
+
+  frame_painter()->PaintFrame(timestamp_to_paint, &rgb_buffer_[0]);
+
+  static const int kQuality = 75;
+  bool success = gfx::JPEGCodec::Encode(
+      &rgb_buffer_[0], gfx::JPEGCodec::FORMAT_RGB,
+      device_state()->format.frame_size.width(),
+      device_state()->format.frame_size.height(),
+      VideoFrame::RowBytes(0 /* plane */, PIXEL_FORMAT_RGB24,
+                           device_state()->format.frame_size.width()),
+      kQuality, &jpeg_buffer_);
+  if (!success) {
+    DLOG(ERROR) << "Jpeg encoding failed";
+    return;
+  }
+
+  const size_t frame_size = jpeg_buffer_.size();
+  base::TimeTicks now = base::TimeTicks::Now();
+  client()->OnIncomingCapturedData(&jpeg_buffer_[0], frame_size,
+                                   device_state()->format, 0 /* rotation */,
+                                   now, CalculateTimeSinceFirstInvocation(now));
+}
+
 OwnBufferFrameDeliverer::OwnBufferFrameDeliverer(
     std::unique_ptr<PacmanFramePainter> frame_painter)
     : FrameDeliverer(std::move(frame_painter)) {}
 
 OwnBufferFrameDeliverer::~OwnBufferFrameDeliverer() = default;
 
-void OwnBufferFrameDeliverer::Initialize(
-    VideoPixelFormat pixel_format,
-    std::unique_ptr<VideoCaptureDevice::Client> client,
-    const FakeDeviceState* device_state) {
-  client_ = std::move(client);
-  device_state_ = device_state;
+void OwnBufferFrameDeliverer::InitializeDerived(VideoPixelFormat pixel_format) {
   buffer_.reset(new uint8_t[VideoFrame::AllocationSize(
-      pixel_format, device_state_->format.frame_size)]);
+      pixel_format, device_state()->format.frame_size)]);
 }
 
-void OwnBufferFrameDeliverer::Uninitialize() {
-  client_.reset();
-  device_state_ = nullptr;
+void OwnBufferFrameDeliverer::UninitializeDerived() {
   buffer_.reset();
 }
 
 void OwnBufferFrameDeliverer::PaintAndDeliverNextFrame(
     base::TimeDelta timestamp_to_paint) {
-  if (!client_)
+  if (!has_client())
     return;
-  const size_t frame_size = device_state_->format.ImageAllocationSize();
+  const size_t frame_size = device_state()->format.ImageAllocationSize();
   memset(buffer_.get(), 0, frame_size);
-  frame_painter_->PaintFrame(timestamp_to_paint, buffer_.get());
+  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 */, now,
-                                  CalculateTimeSinceFirstInvocation(now));
+  client()->OnIncomingCapturedData(buffer_.get(), frame_size,
+                                   device_state()->format, 0 /* rotation */,
+                                   now, CalculateTimeSinceFirstInvocation(now));
 }
 
 ClientBufferFrameDeliverer::ClientBufferFrameDeliverer(
     std::unique_ptr<PacmanFramePainter> frame_painter)
     : FrameDeliverer(std::move(frame_painter)) {}
 
 ClientBufferFrameDeliverer::~ClientBufferFrameDeliverer() = default;
 
-void ClientBufferFrameDeliverer::Initialize(
-    VideoPixelFormat,
-    std::unique_ptr<VideoCaptureDevice::Client> client,
-    const FakeDeviceState* device_state) {
-  client_ = std::move(client);
-  device_state_ = device_state;
-}
-
-void ClientBufferFrameDeliverer::Uninitialize() {
-  client_.reset();
-  device_state_ = nullptr;
-}
-
 void ClientBufferFrameDeliverer::PaintAndDeliverNextFrame(
     base::TimeDelta timestamp_to_paint) {
-  if (client_ == nullptr)
+  if (!has_client())
     return;
 
   const int arbitrary_frame_feedback_id = 0;
-  auto capture_buffer = client_->ReserveOutputBuffer(
-      device_state_->format.frame_size, device_state_->format.pixel_format,
-      device_state_->format.pixel_storage, arbitrary_frame_feedback_id);
+  auto capture_buffer = client()->ReserveOutputBuffer(
+      device_state()->format.frame_size, device_state()->format.pixel_format,
+      device_state()->format.pixel_storage, arbitrary_frame_feedback_id);
   DLOG_IF(ERROR, !capture_buffer.is_valid())
       << "Couldn't allocate Capture Buffer";
   auto buffer_access =
       capture_buffer.handle_provider->GetHandleForInProcessAccess();
   DCHECK(buffer_access->data()) << "Buffer has NO backing memory";
 
-  DCHECK_EQ(PIXEL_STORAGE_CPU, device_state_->format.pixel_storage);
+  DCHECK_EQ(PIXEL_STORAGE_CPU, device_state()->format.pixel_storage);
 
   uint8_t* data_ptr = buffer_access->data();
   memset(data_ptr, 0, buffer_access->mapped_size());
-  frame_painter_->PaintFrame(timestamp_to_paint, data_ptr);
+  frame_painter()->PaintFrame(timestamp_to_paint, data_ptr);
 
   base::TimeTicks now = base::TimeTicks::Now();
-  client_->OnIncomingCapturedBuffer(std::move(capture_buffer),
-                                    device_state_->format, now,
-                                    CalculateTimeSinceFirstInvocation(now));
+  client()->OnIncomingCapturedBuffer(std::move(capture_buffer),
+                                     device_state()->format, now,
+                                     CalculateTimeSinceFirstInvocation(now));
 }
 
 void FakeVideoCaptureDevice::BeepAndScheduleNextCapture(
     base::TimeTicks expected_execution_time) {
   DCHECK(thread_checker_.CalledOnValidThread());
   const base::TimeDelta beep_interval =
       base::TimeDelta::FromMilliseconds(kBeepInterval);
   const base::TimeDelta frame_interval =
       base::TimeDelta::FromMicroseconds(1e6 / device_state_->format.frame_rate);
   beep_time_ += frame_interval;
   elapsed_time_ += frame_interval;
 
   // Generate a synchronized beep twice per second.
   if (beep_time_ >= beep_interval) {
     FakeAudioInputStream::BeepOnce();
     beep_time_ -= beep_interval;
   }
 
   // Reschedule next CaptureTask.
   const base::TimeTicks current_time = base::TimeTicks::Now();
   // Don't accumulate any debt if we are lagging behind - just post the next
   // frame immediately and continue as normal.
   const base::TimeTicks next_execution_time =
       std::max(current_time, expected_execution_time + frame_interval);
   const base::TimeDelta delay = next_execution_time - current_time;
   base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
-      FROM_HERE, base::Bind(&FakeVideoCaptureDevice::OnNextFrameDue,
-                            weak_factory_.GetWeakPtr(), next_execution_time,
-                            current_session_id_),
+      FROM_HERE,
+      base::Bind(&FakeVideoCaptureDevice::OnNextFrameDue,
+                 weak_factory_.GetWeakPtr(), next_execution_time,
+                 current_session_id_),
       delay);
 }
 
 void FakeVideoCaptureDevice::OnNextFrameDue(
     base::TimeTicks expected_execution_time,
     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