[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 86 matching lines @@
 };
 
 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),
       buffer_pool_(std::move(buffer_pool)),
-      last_captured_pixel_format_(media::PIXEL_FORMAT_UNKNOWN) {}
+      last_captured_pixel_format_(media::PIXEL_FORMAT_UNKNOWN) {
+  on_started_using_gpu_cb_ =
+      base::Bind(&VideoFrameReceiver::OnStartedUsingGpuDecode,
+                 base::Unretained(receiver_.get()));
+}
 
 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 156 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) {
+      if (on_started_using_gpu_cb_)
+        std::move(on_started_using_gpu_cb_).Run();

[sandersd (OOO until July 31), 2017/03/14 23:02:34]

Does std::move() actually do anything here? Is this intended to do the same
thing as base::ResetAndReturn() (if so, prefer that).

[chfremer, 2017/03/15 17:31:05]

|on_started_using_gpu_cb_| is a OnceClosure. On OnceClosure and OnceCallback,
using std::move is the standard way of calling Run(). base::ResetAndReturn does
not work on OnceCallbacks.

       external_jpeg_decoder_->DecodeCapturedData(
           data, length, format, reference_time, timestamp, std::move(buffer));
       return;
     }
   }
 
   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(),
@@ skipping 35 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 119 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