Break tight coupling of VideoCaptureDeviceClient to renderer_host

content/browser/renderer_host/media/video_capture_gpu_jpeg_decoder.h

 // Copyright 2015 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.
 
 #ifndef CONTENT_BROWSER_RENDERER_HOST_MEDIA_VIDEO_CAPTURE_GPU_JPEG_DECODER_H_
 #define CONTENT_BROWSER_RENDERER_HOST_MEDIA_VIDEO_CAPTURE_GPU_JPEG_DECODER_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 13 matching lines @@
 namespace gpu {
 class GpuChannelHost;
 }
 
 namespace media {
 class VideoFrame;
 }
 
 namespace content {
 
-// Adapter to GpuJpegDecodeAccelerator for VideoCaptureDevice::Client. It takes
-// care of GpuJpegDecodeAccelerator creation, shared memory, and threading
-// issues.
-//
-// All public methods except JpegDecodeAccelerator::Client ones should be called
-// on the same thread. JpegDecodeAccelerator::Client methods should be called on
-// the IO thread.
-class CONTENT_EXPORT VideoCaptureGpuJpegDecoder
-    : public media::JpegDecodeAccelerator::Client,
-      public base::NonThreadSafe,
-      public base::SupportsWeakPtr<VideoCaptureGpuJpegDecoder> {
+class CONTENT_EXPORT VideoCaptureJpegDecoder {
  public:
   // Enumeration of decoder status. The enumeration is published for clients to
   // decide the behavior according to STATUS.
   enum STATUS {
     INIT_PENDING,  // Default value while waiting initialization finished.
     INIT_PASSED,   // Initialization succeed.
     FAILED,        // JPEG decode is not supported, initialization failed, or
                    // decode error.
   };
 
-  typedef base::Callback<void(
+  using DecodeDoneCB = base::Callback<void(
       std::unique_ptr<media::VideoCaptureDevice::Client::Buffer>,
-      const scoped_refptr<media::VideoFrame>&)>
-      DecodeDoneCB;
+      const scoped_refptr<media::VideoFrame>&)>;
 
+  virtual ~VideoCaptureJpegDecoder() {}
+
+  // Creates and intializes decoder asynchronously.
+  virtual void Initialize() = 0;
+
+  // Returns initialization status.
+  virtual STATUS GetStatus() = 0;
+
+  // Decodes a JPEG picture.
+  virtual void DecodeCapturedData(
+      const uint8_t* data,
+      size_t in_buffer_size,
+      const media::VideoCaptureFormat& frame_format,
+      base::TimeTicks reference_time,
+      base::TimeDelta timestamp,
+      std::unique_ptr<media::VideoCaptureDevice::Client::Buffer>
+          out_buffer) = 0;
+};
+
+class CONTENT_EXPORT VideoCaptureJpegDecoderFactory {

[emircan, 2016/09/08 19:57:56]

Can you look if there is test coverage for this class? AFAIK, this only kicks in
for some CrOS devices when there is MJPEG camera input. They might not be
running on the waterfall.

[chfremer, 2016/09/09 00:55:38]

For this CL I am not too worried (yet) about breaking anything, since extracting
the interfaces seems relatively safe.

I will look into the test coverage question before moving on with the next CL.
If I find that there is no tests exercising this, I will consider adding some
before moving on.

Added this task as CL1.6.1.1 to the design doc [1].

[1]
https://docs.google.com/document/d/1Qw7rw1AJy0QHXjha36jZNiEuxsxWslJ_X-zpOhijv...

[emircan, 2016/09/10 00:08:46]

Thanks for adding the task. For now, we can test at least AppRTC loopback on
Cros with HW MJPEG. This CL actually touches the production code and most CrOS
testing is done manually AFAIK.

+ public:
+  virtual ~VideoCaptureJpegDecoderFactory() {}
+  virtual std::unique_ptr<VideoCaptureJpegDecoder> CreateJpegDecoder() = 0;
+};
+
+// Adapter to GpuJpegDecodeAccelerator for VideoCaptureDevice::Client. It takes
+// care of GpuJpegDecodeAccelerator creation, shared memory, and threading
+// issues.
+//
+// All public methods except JpegDecodeAccelerator::Client ones should be called
+// on the same thread. JpegDecodeAccelerator::Client methods should be called on
+// the IO thread.
+class CONTENT_EXPORT VideoCaptureGpuJpegDecoder
+    : public VideoCaptureJpegDecoder,
+      public media::JpegDecodeAccelerator::Client,
+      public base::NonThreadSafe,
+      public base::SupportsWeakPtr<VideoCaptureGpuJpegDecoder> {
+ public:
   // |decode_done_cb| is called on the IO thread when decode succeed. This can
   // be on any thread. |decode_done_cb| is never called after
   // VideoCaptureGpuJpegDecoder is destroyed.
   explicit VideoCaptureGpuJpegDecoder(const DecodeDoneCB& decode_done_cb);
   ~VideoCaptureGpuJpegDecoder() override;
 
-  // Creates and intializes decoder asynchronously.
-  void Initialize();
-
-  // Returns initialization status.
-  STATUS GetStatus() const;
-
-  // Decodes a JPEG picture.
+  // Implementation of VideoCaptureGpuJpegDecoderInterface:
+  void Initialize() override;
+  STATUS GetStatus() override;
   void DecodeCapturedData(
       const uint8_t* data,
       size_t in_buffer_size,
       const media::VideoCaptureFormat& frame_format,
       base::TimeTicks reference_time,
       base::TimeDelta timestamp,
-      std::unique_ptr<media::VideoCaptureDevice::Client::Buffer> out_buffer);
+      std::unique_ptr<media::VideoCaptureDevice::Client::Buffer> out_buffer)
+      override;
 
   // JpegDecodeAccelerator::Client implementation.
   // These will be called on IO thread.
   void VideoFrameReady(int32_t buffer_id) override;
   void NotifyError(int32_t buffer_id,
                    media::JpegDecodeAccelerator::Error error) override;
 
  private:
   // Initialization helper, to establish GPU channel.
   static void EstablishGpuChannelOnUIThread(
@@ skipping 39 matching lines @@
   std::unique_ptr<base::SharedMemory> in_shared_memory_;
 
   STATUS decoder_status_;
 
   DISALLOW_COPY_AND_ASSIGN(VideoCaptureGpuJpegDecoder);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_RENDERER_HOST_MEDIA_VIDEO_CAPTURE_GPU_JPEG_DECODER_H_