[Mojo Video Capture] Add test coverage for accelerated jpeg decoding

media/capture/video/video_capture_device_client.cc

 // 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.
 
 #include "media/capture/video/video_capture_device_client.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 85 matching lines @@
   const int buffer_id_;
 };
 
 VideoCaptureDeviceClient::VideoCaptureDeviceClient(
     std::unique_ptr<VideoFrameReceiver> receiver,
     scoped_refptr<VideoCaptureBufferPool> buffer_pool,
     const VideoCaptureJpegDecoderFactoryCB& jpeg_decoder_factory)
     : receiver_(std::move(receiver)),
       jpeg_decoder_factory_callback_(jpeg_decoder_factory),
       external_jpeg_decoder_initialized_(false),
+      using_external_jpeg_decoder_(false),
       buffer_pool_(std::move(buffer_pool)),
       last_captured_pixel_format_(media::PIXEL_FORMAT_UNKNOWN) {}
 
 VideoCaptureDeviceClient::~VideoCaptureDeviceClient() {
   // This should be on the platform auxiliary thread since
   // |external_jpeg_decoder_| need to be destructed on the same thread as
   // OnIncomingCapturedData.
 
   for (int buffer_id : buffer_ids_known_by_receiver_)
     receiver_->OnBufferRetired(buffer_id);
@@ skipping 158 matching lines @@
   DCHECK_GE(static_cast<size_t>(length), format.ImageAllocationSize());
 
   if (external_jpeg_decoder_) {
     const VideoCaptureJpegDecoder::STATUS status =
         external_jpeg_decoder_->GetStatus();
     if (status == VideoCaptureJpegDecoder::FAILED) {
       external_jpeg_decoder_.reset();
     } else if (status == VideoCaptureJpegDecoder::INIT_PASSED &&
                format.pixel_format == media::PIXEL_FORMAT_MJPEG &&
                rotation == 0 && !flip) {
+      OnUsingExternalJpegDecoder();
       external_jpeg_decoder_->DecodeCapturedData(
           data, length, format, reference_time, timestamp, std::move(buffer));
       return;
     }
   }
+  OnNotUsingExternalJpegDecoder();
 
   if (libyuv::ConvertToI420(
           data, length, y_plane_data, yplane_stride, u_plane_data,
           uv_plane_stride, v_plane_data, uv_plane_stride, crop_x, crop_y,
           format.frame_size.width(),
           (flip ? -1 : 1) * format.frame_size.height(), new_unrotated_width,
           new_unrotated_height, rotation_mode, origin_colorspace) != 0) {
     DLOG(WARNING) << "Failed to convert buffer's pixel format to I420 from "
                   << media::VideoPixelFormatToString(format.pixel_format);
     return;
@@ skipping 30 matching lines @@
     if (entry_iter != buffer_ids_known_by_receiver_.end()) {
       buffer_ids_known_by_receiver_.erase(entry_iter);
       receiver_->OnBufferRetired(buffer_id_to_drop);
     }
   }
   if (buffer_id == VideoCaptureBufferPool::kInvalidId)
     return Buffer();
 
   if (!base::ContainsValue(buffer_ids_known_by_receiver_, buffer_id)) {
     receiver_->OnNewBufferHandle(
-        buffer_id,
-        base::MakeUnique<BufferPoolBufferHandleProvider>(buffer_pool_,
-                                                         buffer_id));
+        buffer_id, base::MakeUnique<BufferPoolBufferHandleProvider>(
+                       buffer_pool_, buffer_id));
     buffer_ids_known_by_receiver_.push_back(buffer_id);
   }
 
   return MakeBufferStruct(buffer_pool_, buffer_id, frame_feedback_id);
 }
 
 void VideoCaptureDeviceClient::OnIncomingCapturedBuffer(
     Buffer buffer,
     const VideoCaptureFormat& format,
     base::TimeTicks reference_time,
@@ skipping 67 matching lines @@
 }
 
 void VideoCaptureDeviceClient::OnStarted() {
   receiver_->OnStarted();
 }
 
 double VideoCaptureDeviceClient::GetBufferPoolUtilization() const {
   return buffer_pool_->GetBufferPoolUtilization();
 }
 
+void VideoCaptureDeviceClient::OnUsingExternalJpegDecoder() {
+  if (using_external_jpeg_decoder_)
+    return;
+  using_external_jpeg_decoder_ = true;
+  receiver_->OnStartedUsingGpuDecode();
+}
+
+void VideoCaptureDeviceClient::OnNotUsingExternalJpegDecoder() {
+  if (!using_external_jpeg_decoder_)
+    return;
+  using_external_jpeg_decoder_ = false;
+  receiver_->OnStoppedUsingGpuDecode();
+}
+
 void VideoCaptureDeviceClient::InitializeI420PlanePointers(
     const gfx::Size& dimensions,
     uint8_t* const data,
     uint8_t** y_plane_data,
     uint8_t** u_plane_data,
     uint8_t** v_plane_data) {
   DCHECK(dimensions.height());
   DCHECK(dimensions.width());
 
   const media::VideoPixelFormat format = media::PIXEL_FORMAT_I420;
@@ skipping 32 matching lines @@
   auto buffer_access = buffer.handle_provider->GetHandleForInProcessAccess();
   memcpy(buffer_access->data(), data, length);
   const VideoCaptureFormat output_format =
       VideoCaptureFormat(format.frame_size, format.frame_rate,
                          media::PIXEL_FORMAT_Y16, media::PIXEL_STORAGE_CPU);
   OnIncomingCapturedBuffer(std::move(buffer), output_format, reference_time,
                            timestamp);
 }
 
 }  // namespace media