[Mojo Video Capture] Replace RESOURCE_UTILIZATION with interface ReceiverLoadObserver

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 23 matching lines @@
           pixel_format == media::PIXEL_FORMAT_Y16);
 }
 }
 
 namespace media {
 
 // Class combining a Client::Buffer interface implementation and a pool buffer
 // implementation to guarantee proper cleanup on destruction on our side.
 class AutoReleaseBuffer : public media::VideoCaptureDevice::Client::Buffer {
  public:
-  AutoReleaseBuffer(scoped_refptr<VideoCaptureBufferPool> pool, int buffer_id)
+  AutoReleaseBuffer(scoped_refptr<VideoCaptureBufferPool> pool,
+                    int buffer_id,
+                    int frame_feedback_id)
       : id_(buffer_id),
+        frame_feedback_id_(frame_feedback_id),
         pool_(std::move(pool)),

[miu, 2016/12/02 23:29:32]

nit: pool_ should go first as a data member, and in this initializer list, to
retain the same ordering as the ctor args.

[chfremer, 2016/12/03 00:30:35]

Done.

         buffer_handle_(pool_->GetBufferHandle(buffer_id)) {
     DCHECK(pool_.get());
   }
   int id() const override { return id_; }
+  int frame_feedback_id() const override { return frame_feedback_id_; }
   gfx::Size dimensions() const override { return buffer_handle_->dimensions(); }
   size_t mapped_size() const override { return buffer_handle_->mapped_size(); }
   void* data(int plane) override { return buffer_handle_->data(plane); }
 #if defined(OS_POSIX) && !defined(OS_MACOSX)
   base::FileDescriptor AsPlatformFile() override {
     return buffer_handle_->AsPlatformFile();
   }
 #endif
   bool IsBackedByVideoFrame() const override {
     return buffer_handle_->IsBackedByVideoFrame();
   }
   scoped_refptr<VideoFrame> GetVideoFrame() override {
     return buffer_handle_->GetVideoFrame();
   }
 
  private:
   ~AutoReleaseBuffer() override { pool_->RelinquishProducerReservation(id_); }
 
   const int id_;
+  const int frame_feedback_id_;
   const scoped_refptr<VideoCaptureBufferPool> pool_;
   const std::unique_ptr<VideoCaptureBufferHandle> buffer_handle_;
 };
 
 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) {}
 
 VideoCaptureDeviceClient::~VideoCaptureDeviceClient() {
   // This should be on the platform auxiliary thread since
   // |external_jpeg_decoder_| need to be destructed on the same thread as
   // OnIncomingCapturedData.
 }
 
 void VideoCaptureDeviceClient::OnIncomingCapturedData(
     const uint8_t* data,
     int length,
     const VideoCaptureFormat& frame_format,
     int rotation,
     base::TimeTicks reference_time,
-    base::TimeDelta timestamp) {
+    base::TimeDelta timestamp,
+    int frame_feedback_id) {
   TRACE_EVENT0("video", "VideoCaptureDeviceClient::OnIncomingCapturedData");
   DCHECK_EQ(media::PIXEL_STORAGE_CPU, frame_format.pixel_storage);
 
   if (last_captured_pixel_format_ != frame_format.pixel_format) {
     OnLog("Pixel format: " +
           media::VideoPixelFormatToString(frame_format.pixel_format));
     last_captured_pixel_format_ = frame_format.pixel_format;
 
     if (frame_format.pixel_format == media::PIXEL_FORMAT_MJPEG &&
         !external_jpeg_decoder_initialized_) {
       external_jpeg_decoder_initialized_ = true;
       external_jpeg_decoder_ = jpeg_decoder_factory_callback_.Run();
       external_jpeg_decoder_->Initialize();
     }
   }
 
   if (!frame_format.IsValid())
     return;
 
   if (frame_format.pixel_format == media::PIXEL_FORMAT_Y16) {
     return OnIncomingCapturedY16Data(data, length, frame_format, reference_time,
-                                     timestamp);
+                                     timestamp, frame_feedback_id);
   }
 
   // |chopped_{width,height} and |new_unrotated_{width,height}| are the lowest
   // bit decomposition of {width, height}, grabbing the odd and even parts.
   const int chopped_width = frame_format.frame_size.width() & 1;
   const int chopped_height = frame_format.frame_size.height() & 1;
   const int new_unrotated_width = frame_format.frame_size.width() & ~1;
   const int new_unrotated_height = frame_format.frame_size.height() & ~1;
 
   int destination_width = new_unrotated_width;
   int destination_height = new_unrotated_height;
   if (rotation == 90 || rotation == 270)
     std::swap(destination_width, destination_height);
 
   DCHECK_EQ(0, rotation % 90) << " Rotation must be a multiple of 90, now: "
                               << rotation;
   libyuv::RotationMode rotation_mode = libyuv::kRotate0;
   if (rotation == 90)
     rotation_mode = libyuv::kRotate90;
   else if (rotation == 180)
     rotation_mode = libyuv::kRotate180;
   else if (rotation == 270)
     rotation_mode = libyuv::kRotate270;
 
   const gfx::Size dimensions(destination_width, destination_height);
   uint8_t *y_plane_data, *u_plane_data, *v_plane_data;
-  std::unique_ptr<Buffer> buffer(
-      ReserveI420OutputBuffer(dimensions, media::PIXEL_STORAGE_CPU,
-                              &y_plane_data, &u_plane_data, &v_plane_data));
+  std::unique_ptr<Buffer> buffer(ReserveI420OutputBuffer(
+      dimensions, media::PIXEL_STORAGE_CPU, frame_feedback_id, &y_plane_data,
+      &u_plane_data, &v_plane_data));
 #if DCHECK_IS_ON()
   dropped_frame_counter_ = buffer.get() ? 0 : dropped_frame_counter_ + 1;
   if (dropped_frame_counter_ >= kMaxDroppedFrames)
     OnError(FROM_HERE, "Too many frames dropped");
 #endif
   // Failed to reserve I420 output buffer, so drop the frame.
   if (!buffer.get())
     return;
 
   const int yplane_stride = dimensions.width();
@@ skipping 101 matching lines @@
       VideoCaptureFormat(dimensions, frame_format.frame_rate,
                          media::PIXEL_FORMAT_I420, media::PIXEL_STORAGE_CPU);
   OnIncomingCapturedBuffer(std::move(buffer), output_format, reference_time,
                            timestamp);
 }
 
 std::unique_ptr<media::VideoCaptureDevice::Client::Buffer>
 VideoCaptureDeviceClient::ReserveOutputBuffer(
     const gfx::Size& frame_size,
     media::VideoPixelFormat pixel_format,
-    media::VideoPixelStorage pixel_storage) {
+    media::VideoPixelStorage pixel_storage,
+    int frame_feedback_id) {
   DCHECK_GT(frame_size.width(), 0);
   DCHECK_GT(frame_size.height(), 0);
   DCHECK(IsFormatSupported(pixel_format));
 
   // TODO(mcasas): For PIXEL_STORAGE_GPUMEMORYBUFFER, find a way to indicate if
   // it's a ShMem GMB or a DmaBuf GMB.
   int buffer_id_to_drop = VideoCaptureBufferPool::kInvalidId;
-  const int buffer_id = buffer_pool_->ReserveForProducer(
-      frame_size, pixel_format, pixel_storage, &buffer_id_to_drop);
+  const int buffer_id =
+      buffer_pool_->ReserveForProducer(frame_size, pixel_format, pixel_storage,
+                                       frame_feedback_id, &buffer_id_to_drop);
   if (buffer_id_to_drop != VideoCaptureBufferPool::kInvalidId)
     receiver_->OnBufferDestroyed(buffer_id_to_drop);
   if (buffer_id == VideoCaptureBufferPool::kInvalidId)
     return nullptr;
   return base::WrapUnique<Buffer>(
-      new AutoReleaseBuffer(buffer_pool_, buffer_id));
+      new AutoReleaseBuffer(buffer_pool_, buffer_id, frame_feedback_id));
 }
 
 void VideoCaptureDeviceClient::OnIncomingCapturedBuffer(
     std::unique_ptr<Buffer> buffer,
     const VideoCaptureFormat& frame_format,
     base::TimeTicks reference_time,
     base::TimeDelta timestamp) {
   DCHECK(IsFormatSupported(frame_format.pixel_format));
   DCHECK_EQ(media::PIXEL_STORAGE_CPU, frame_format.pixel_storage);
 
@@ skipping 22 matching lines @@
 void VideoCaptureDeviceClient::OnIncomingCapturedVideoFrame(
     std::unique_ptr<Buffer> buffer,
     scoped_refptr<VideoFrame> frame) {
   receiver_->OnIncomingCapturedVideoFrame(std::move(buffer), std::move(frame));
 }
 
 std::unique_ptr<media::VideoCaptureDevice::Client::Buffer>
 VideoCaptureDeviceClient::ResurrectLastOutputBuffer(
     const gfx::Size& dimensions,
     media::VideoPixelFormat format,
-    media::VideoPixelStorage storage) {
+    media::VideoPixelStorage storage,
+    int new_frame_feedback_id) {
   const int buffer_id =
       buffer_pool_->ResurrectLastForProducer(dimensions, format, storage);
   if (buffer_id == VideoCaptureBufferPool::kInvalidId)
     return nullptr;
   return base::WrapUnique<Buffer>(
-      new AutoReleaseBuffer(buffer_pool_, buffer_id));
+      new AutoReleaseBuffer(buffer_pool_, buffer_id, new_frame_feedback_id));
 }
 
 void VideoCaptureDeviceClient::OnError(
     const tracked_objects::Location& from_here,
     const std::string& reason) {
   const std::string log_message = base::StringPrintf(
       "error@ %s, %s, OS message: %s", from_here.ToString().c_str(),
       reason.c_str(),
       logging::SystemErrorCodeToString(logging::GetLastSystemErrorCode())
           .c_str());
   DLOG(ERROR) << log_message;
   OnLog(log_message);
   receiver_->OnError();
 }
 
 void VideoCaptureDeviceClient::OnLog(const std::string& message) {
   receiver_->OnLog(message);
 }
 
 double VideoCaptureDeviceClient::GetBufferPoolUtilization() const {
   return buffer_pool_->GetBufferPoolUtilization();
 }
 
 std::unique_ptr<media::VideoCaptureDevice::Client::Buffer>
 VideoCaptureDeviceClient::ReserveI420OutputBuffer(
     const gfx::Size& dimensions,
     media::VideoPixelStorage storage,
+    int frame_feedback_id,
     uint8_t** y_plane_data,
     uint8_t** u_plane_data,
     uint8_t** v_plane_data) {
   DCHECK(storage == media::PIXEL_STORAGE_CPU);
   DCHECK(dimensions.height());
   DCHECK(dimensions.width());
 
   const media::VideoPixelFormat format = media::PIXEL_FORMAT_I420;
-  std::unique_ptr<Buffer> buffer(
-      ReserveOutputBuffer(dimensions, media::PIXEL_FORMAT_I420, storage));
+  std::unique_ptr<Buffer> buffer(ReserveOutputBuffer(
+      dimensions, media::PIXEL_FORMAT_I420, storage, frame_feedback_id));
   if (!buffer)
     return std::unique_ptr<Buffer>();
   // TODO(emircan): See http://crbug.com/521068, move this pointer
   // arithmetic inside Buffer::data() when this bug is resolved.
   *y_plane_data = reinterpret_cast<uint8_t*>(buffer->data());
   *u_plane_data =
       *y_plane_data +
       VideoFrame::PlaneSize(format, VideoFrame::kYPlane, dimensions).GetArea();
   *v_plane_data =
       *u_plane_data +
       VideoFrame::PlaneSize(format, VideoFrame::kUPlane, dimensions).GetArea();
   return buffer;
 }
 
 void VideoCaptureDeviceClient::OnIncomingCapturedY16Data(
     const uint8_t* data,
     int length,
     const VideoCaptureFormat& frame_format,
     base::TimeTicks reference_time,
-    base::TimeDelta timestamp) {
-  std::unique_ptr<Buffer> buffer(ReserveOutputBuffer(frame_format.frame_size,
-                                                     media::PIXEL_FORMAT_Y16,
-                                                     media::PIXEL_STORAGE_CPU));
+    base::TimeDelta timestamp,
+    int frame_feedback_id) {
+  std::unique_ptr<Buffer> buffer(
+      ReserveOutputBuffer(frame_format.frame_size, media::PIXEL_FORMAT_Y16,
+                          media::PIXEL_STORAGE_CPU, frame_feedback_id));
   // The input |length| can be greater than the required buffer size because of
   // paddings and/or alignments, but it cannot be smaller.
   DCHECK_GE(static_cast<size_t>(length), frame_format.ImageAllocationSize());
 #if DCHECK_IS_ON()
   dropped_frame_counter_ = buffer.get() ? 0 : dropped_frame_counter_ + 1;
   if (dropped_frame_counter_ >= kMaxDroppedFrames)
     OnError(FROM_HERE, "Too many frames dropped");
 #endif
   // Failed to reserve output buffer, so drop the frame.
   if (!buffer.get())
     return;
   memcpy(buffer->data(), data, length);
   const VideoCaptureFormat output_format =
       VideoCaptureFormat(frame_format.frame_size, frame_format.frame_rate,
                          media::PIXEL_FORMAT_Y16, media::PIXEL_STORAGE_CPU);
   OnIncomingCapturedBuffer(std::move(buffer), output_format, reference_time,
                            timestamp);
 }
 
 }  // namespace media